From fcb05906237a4c6844c67c2e5413b124b9d7592f Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Tue, 28 May 2024 10:32:52 +0200
Subject: [PATCH 01/24] kernel: Introduce initial kernel C header API

As a first step, implement the equivalent of what was implemented in the
now deprecated libbitcoinconsensus header. Also add a test binary to
exercise the header and library.

Unlike the deprecated libbitcoinconsensus the kernel library can now use
the hardware-accelerated sha256 implementations thanks for its
statically-initialzed context. The functions kept around for
backwards-compatibility in the libbitcoinconsensus header are not ported
over. As a new header, it should not be burdened by previous
implementations. Also add a new error code for handling invalid flag
combinations, which would otherwise cause a crash.

The macros used in the new C header were adapted from the libsecp256k1
header.

To make use of the C header from C++ code, a C++ header is also
introduced for wrapping the C header. This makes it safer and easier to
use from C++ code.

Co-authored-by: stickies-v <stickies-v@protonmail.com>
---
 .github/ci-test-each-commit-exec.py           |   2 +
 .github/workflows/ci.yml                      |   2 +-
 CMakeLists.txt                                |   3 +
 ci/test/00_setup_env_mac_native.sh            |   2 +-
 ...up_env_native_nowallet_libbitcoinkernel.sh |   2 +-
 ci/test/00_setup_env_win64.sh                 |   2 +-
 src/CMakeLists.txt                            |   3 +
 src/kernel/CMakeLists.txt                     |   7 +
 src/kernel/bitcoinkernel.cpp                  | 246 +++++++++-
 src/kernel/bitcoinkernel.h                    | 341 ++++++++++++++
 src/kernel/bitcoinkernel_wrapper.h            | 444 ++++++++++++++++++
 src/test/kernel/CMakeLists.txt                |  16 +
 src/test/kernel/test_kernel.cpp               | 350 ++++++++++++++
 13 files changed, 1414 insertions(+), 6 deletions(-)
 create mode 100644 src/kernel/bitcoinkernel.h
 create mode 100644 src/kernel/bitcoinkernel_wrapper.h
 create mode 100644 src/test/kernel/CMakeLists.txt
 create mode 100644 src/test/kernel/test_kernel.cpp

diff --git a/.github/ci-test-each-commit-exec.py b/.github/ci-test-each-commit-exec.py
index 3b2eaeeb596..959a1579aea 100755
--- a/.github/ci-test-each-commit-exec.py
+++ b/.github/ci-test-each-commit-exec.py
@@ -42,6 +42,8 @@ def main():
         "-DBUILD_BENCH=ON",
         "-DBUILD_FUZZ_BINARY=ON",
         "-DWITH_USDT=ON",
+        "-DBUILD_KERNEL_LIB=ON",
+        "-DBUILD_KERNEL_TEST=ON",
         "-DCMAKE_CXX_FLAGS=-Wno-error=unused-member-function",
     ])
     run(["cmake", "--build", "build", "-j", str(num_procs)])
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f5a6f9ab90f..7e4dea822f2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -202,7 +202,7 @@ jobs:
         job-type: [standard, fuzz]
         include:
           - job-type: standard
-            generate-options: '-DBUILD_GUI=ON -DWITH_ZMQ=ON -DBUILD_BENCH=ON -DWERROR=ON'
+            generate-options: '-DBUILD_GUI=ON -DWITH_ZMQ=ON -DBUILD_BENCH=ON -DBUILD_KERNEL_LIB=ON -DWERROR=ON'
             job-name: 'Windows native, VS 2022'
           - job-type: fuzz
             generate-options: '-DVCPKG_MANIFEST_NO_DEFAULT_FEATURES=ON -DVCPKG_MANIFEST_FEATURES="wallet" -DBUILD_GUI=OFF -DBUILD_FOR_FUZZING=ON -DWERROR=ON'
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4c10fb73fad..2e5196c2fbe 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -105,6 +105,7 @@ option(BUILD_UTIL "Build bitcoin-util executable." ${BUILD_TESTS})
 
 option(BUILD_UTIL_CHAINSTATE "Build experimental bitcoin-chainstate executable." OFF)
 option(BUILD_KERNEL_LIB "Build experimental bitcoinkernel library." ${BUILD_UTIL_CHAINSTATE})
+option(BUILD_KERNEL_TEST "Build tests for the experimental bitcoinkernel library." ${BUILD_KERNEL_LIB})
 
 option(ENABLE_WALLET "Enable wallet." ON)
 if(ENABLE_WALLET)
@@ -210,6 +211,7 @@ if(BUILD_FOR_FUZZING)
   set(BUILD_UTIL OFF)
   set(BUILD_UTIL_CHAINSTATE OFF)
   set(BUILD_KERNEL_LIB OFF)
+  set(BUILD_KERNEL_TEST OFF)
   set(BUILD_WALLET_TOOL OFF)
   set(BUILD_GUI OFF)
   set(ENABLE_EXTERNAL_SIGNER OFF)
@@ -668,6 +670,7 @@ message("  bitcoin-util ........................ ${BUILD_UTIL}")
 message("  bitcoin-wallet ...................... ${BUILD_WALLET_TOOL}")
 message("  bitcoin-chainstate (experimental) ... ${BUILD_UTIL_CHAINSTATE}")
 message("  libbitcoinkernel (experimental) ..... ${BUILD_KERNEL_LIB}")
+message("  kernel-test (experimental) .......... ${BUILD_KERNEL_TEST}")
 message("Optional features:")
 message("  wallet support ...................... ${ENABLE_WALLET}")
 message("  external signer ..................... ${ENABLE_EXTERNAL_SIGNER}")
diff --git a/ci/test/00_setup_env_mac_native.sh b/ci/test/00_setup_env_mac_native.sh
index 41a3bc45877..3584246c257 100755
--- a/ci/test/00_setup_env_mac_native.sh
+++ b/ci/test/00_setup_env_mac_native.sh
@@ -12,7 +12,7 @@ export CONTAINER_NAME="ci_mac_native"  # macos does not use a container, but the
 export PIP_PACKAGES="--break-system-packages zmq"
 export GOAL="install deploy"
 export CMAKE_GENERATOR="Ninja"
-export BITCOIN_CONFIG="-DBUILD_GUI=ON -DWITH_ZMQ=ON -DREDUCE_EXPORTS=ON -DCMAKE_EXE_LINKER_FLAGS='-Wl,-stack_size -Wl,0x80000'"
+export BITCOIN_CONFIG="-DBUILD_GUI=ON -DWITH_ZMQ=ON -DBUILD_KERNEL_LIB=ON -DBUILD_KERNEL_TEST=ON -DREDUCE_EXPORTS=ON -DCMAKE_EXE_LINKER_FLAGS='-Wl,-stack_size -Wl,0x80000'"
 export CI_OS_NAME="macos"
 export NO_DEPENDS=1
 export OSX_SDK=""
diff --git a/ci/test/00_setup_env_native_nowallet_libbitcoinkernel.sh b/ci/test/00_setup_env_native_nowallet_libbitcoinkernel.sh
index 58561e55204..b1e0c65e246 100755
--- a/ci/test/00_setup_env_native_nowallet_libbitcoinkernel.sh
+++ b/ci/test/00_setup_env_native_nowallet_libbitcoinkernel.sh
@@ -13,4 +13,4 @@ export PACKAGES="python3-zmq python3-pip clang-16 llvm-16 libc++abi-16-dev libc+
 export PIP_PACKAGES="--break-system-packages pycapnp"
 export DEP_OPTS="NO_WALLET=1 CC=clang-16 CXX='clang++-16 -stdlib=libc++'"
 export GOAL="install"
-export BITCOIN_CONFIG="-DREDUCE_EXPORTS=ON -DBUILD_UTIL_CHAINSTATE=ON -DBUILD_KERNEL_LIB=ON -DBUILD_SHARED_LIBS=ON"
+export BITCOIN_CONFIG="-DREDUCE_EXPORTS=ON -DBUILD_UTIL_CHAINSTATE=ON -DBUILD_KERNEL_LIB=ON -DBUILD_KERNEL_TEST=ON -DBUILD_SHARED_LIBS=ON"
diff --git a/ci/test/00_setup_env_win64.sh b/ci/test/00_setup_env_win64.sh
index 13e794bd6d1..71e1e36f1d0 100755
--- a/ci/test/00_setup_env_win64.sh
+++ b/ci/test/00_setup_env_win64.sh
@@ -14,5 +14,5 @@ export PACKAGES="g++-mingw-w64-x86-64-posix nsis"
 export RUN_UNIT_TESTS=false
 export RUN_FUNCTIONAL_TESTS=false
 export GOAL="deploy"
-export BITCOIN_CONFIG="-DREDUCE_EXPORTS=ON -DBUILD_GUI_TESTS=OFF \
+export BITCOIN_CONFIG="-DREDUCE_EXPORTS=ON -DBUILD_GUI_TESTS=OFF -DBUILD_KERNEL_LIB=ON -DBUILD_KERNEL_TEST=ON \
 -DCMAKE_CXX_FLAGS='-Wno-error=maybe-uninitialized'"
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index f9934bb5906..7bb5857f47e 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -404,6 +404,9 @@ endif()
 
 if(BUILD_KERNEL_LIB)
   add_subdirectory(kernel)
+  if (BUILD_KERNEL_TEST)
+    add_subdirectory(test/kernel)
+  endif()
 endif()
 
 if(BUILD_UTIL_CHAINSTATE)
diff --git a/src/kernel/CMakeLists.txt b/src/kernel/CMakeLists.txt
index c45ce7819e9..7b2f3c7d11f 100644
--- a/src/kernel/CMakeLists.txt
+++ b/src/kernel/CMakeLists.txt
@@ -110,6 +110,11 @@ set_target_properties(bitcoinkernel PROPERTIES
 add_custom_target(libbitcoinkernel)
 add_dependencies(libbitcoinkernel bitcoinkernel)
 
+get_target_property(bitcoinkernel_type bitcoinkernel TYPE)
+if(bitcoinkernel_type STREQUAL "STATIC_LIBRARY")
+  target_compile_definitions(bitcoinkernel PUBLIC BITCOINKERNEL_STATIC)
+endif()
+
 configure_file(${PROJECT_SOURCE_DIR}/libbitcoinkernel.pc.in ${PROJECT_BINARY_DIR}/libbitcoinkernel.pc @ONLY)
 install(FILES ${PROJECT_BINARY_DIR}/libbitcoinkernel.pc DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig" COMPONENT libbitcoinkernel)
 
@@ -124,3 +129,5 @@ install(TARGETS bitcoinkernel
     DESTINATION ${CMAKE_INSTALL_LIBDIR}
     COMPONENT libbitcoinkernel
 )
+
+install(FILES bitcoinkernel.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} COMPONENT libbitcoinkernel)
diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index 9096b6f71de..4a6b254be23 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -1,11 +1,253 @@
-// Copyright (c) 2022 The Bitcoin Core developers
+// Copyright (c) 2022-present The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#define BITCOINKERNEL_BUILD
+
+#include <kernel/bitcoinkernel.h>
+
+#include <consensus/amount.h>
+#include <kernel/context.h>
+#include <primitives/transaction.h>
+#include <script/interpreter.h>
+#include <script/script.h>
+#include <serialize.h>
+#include <streams.h>
 #include <util/translation.h>
 
+#include <cstddef>
+#include <cstring>
+#include <exception>
 #include <functional>
+#include <span>
 #include <string>
+#include <utility>
+#include <vector>
 
 // Define G_TRANSLATION_FUN symbol in libbitcoinkernel library so users of the
 // library aren't required to export this symbol
-extern const TranslateFn G_TRANSLATION_FUN{nullptr};
+extern const std::function<std::string(const char*)> G_TRANSLATION_FUN{nullptr};
+
+static const kernel::Context btck_context_static{};
+
+namespace {
+
+bool is_valid_flag_combination(script_verify_flags flags)
+{
+    if (flags & SCRIPT_VERIFY_CLEANSTACK && ~flags & (SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS)) return false;
+    if (flags & SCRIPT_VERIFY_WITNESS && ~flags & SCRIPT_VERIFY_P2SH) return false;
+    return true;
+}
+
+class WriterStream
+{
+private:
+    btck_WriteBytes m_writer;
+    void* m_user_data;
+
+public:
+    WriterStream(btck_WriteBytes writer, void* user_data)
+        : m_writer{writer}, m_user_data{user_data} {}
+
+    //
+    // Stream subset
+    //
+    void write(std::span<const std::byte> src)
+    {
+        if (m_writer(std::data(src), src.size(), m_user_data) != 0) {
+            throw std::runtime_error("Failed to write serilization data");
+        }
+    }
+
+    template <typename T>
+    WriterStream& operator<<(const T& obj)
+    {
+        ::Serialize(*this, obj);
+        return *this;
+    }
+};
+
+template <typename C, typename CPP>
+struct Handle {
+    static C* ref(CPP* cpp_type)
+    {
+        return reinterpret_cast<C*>(cpp_type);
+    }
+
+    static const C* ref(const CPP* cpp_type)
+    {
+        return reinterpret_cast<const C*>(cpp_type);
+    }
+
+    template <typename... Args>
+    static C* create(Args&&... args)
+    {
+        auto cpp_obj{std::make_unique<CPP>(std::forward<Args>(args)...)};
+        return reinterpret_cast<C*>(cpp_obj.release());
+    }
+
+    static C* copy(const C* ptr)
+    {
+        auto cpp_obj{std::make_unique<CPP>(get(ptr))};
+        return reinterpret_cast<C*>(cpp_obj.release());
+    }
+
+    static const CPP& get(const C* ptr)
+    {
+        return *reinterpret_cast<const CPP*>(ptr);
+    }
+
+    static void operator delete(void* ptr)
+    {
+        delete reinterpret_cast<CPP*>(ptr);
+    }
+};
+
+} // namespace
+
+struct btck_Transaction : Handle<btck_Transaction, std::shared_ptr<const CTransaction>> {};
+struct btck_TransactionOutput : Handle<btck_TransactionOutput, CTxOut> {};
+struct btck_ScriptPubkey : Handle<btck_ScriptPubkey, CScript> {};
+
+btck_Transaction* btck_transaction_create(const void* raw_transaction, size_t raw_transaction_len)
+{
+    try {
+        DataStream stream{std::span{reinterpret_cast<const std::byte*>(raw_transaction), raw_transaction_len}};
+        return btck_Transaction::create(std::make_shared<const CTransaction>(deserialize, TX_WITH_WITNESS, stream));
+    } catch (...) {
+        return nullptr;
+    }
+}
+
+size_t btck_transaction_count_outputs(const btck_Transaction* transaction)
+{
+    return btck_Transaction::get(transaction)->vout.size();
+}
+
+const btck_TransactionOutput* btck_transaction_get_output_at(const btck_Transaction* transaction, size_t output_index)
+{
+    const CTransaction& tx = *btck_Transaction::get(transaction);
+    assert(output_index < tx.vout.size());
+    return btck_TransactionOutput::ref(&tx.vout[output_index]);
+}
+
+size_t btck_transaction_count_inputs(const btck_Transaction* transaction)
+{
+    return btck_Transaction::get(transaction)->vin.size();
+}
+
+btck_Transaction* btck_transaction_copy(const btck_Transaction* transaction)
+{
+    return btck_Transaction::copy(transaction);
+}
+
+int btck_transaction_to_bytes(const btck_Transaction* transaction, btck_WriteBytes writer, void* user_data)
+{
+    try {
+        WriterStream ws{writer, user_data};
+        ws << TX_WITH_WITNESS(btck_Transaction::get(transaction));
+        return 0;
+    } catch (...) {
+        return -1;
+    }
+}
+
+void btck_transaction_destroy(btck_Transaction* transaction)
+{
+    delete transaction;
+}
+
+btck_ScriptPubkey* btck_script_pubkey_create(const void* script_pubkey, size_t script_pubkey_len)
+{
+    auto data = std::span{reinterpret_cast<const uint8_t*>(script_pubkey), script_pubkey_len};
+    return btck_ScriptPubkey::create(data.begin(), data.end());
+}
+
+int btck_script_pubkey_to_bytes(const btck_ScriptPubkey* script_pubkey_, btck_WriteBytes writer, void* user_data)
+{
+    const auto& script_pubkey{btck_ScriptPubkey::get(script_pubkey_)};
+    return writer(script_pubkey.data(), script_pubkey.size(), user_data);
+}
+
+btck_ScriptPubkey* btck_script_pubkey_copy(const btck_ScriptPubkey* script_pubkey)
+{
+    return btck_ScriptPubkey::copy(script_pubkey);
+}
+
+void btck_script_pubkey_destroy(btck_ScriptPubkey* script_pubkey)
+{
+    delete script_pubkey;
+}
+
+btck_TransactionOutput* btck_transaction_output_create(const btck_ScriptPubkey* script_pubkey, int64_t amount)
+{
+    return btck_TransactionOutput::create(amount, btck_ScriptPubkey::get(script_pubkey));
+}
+
+btck_TransactionOutput* btck_transaction_output_copy(const btck_TransactionOutput* output)
+{
+    return btck_TransactionOutput::copy(output);
+}
+
+const btck_ScriptPubkey* btck_transaction_output_get_script_pubkey(const btck_TransactionOutput* output)
+{
+    return btck_ScriptPubkey::ref(&btck_TransactionOutput::get(output).scriptPubKey);
+}
+
+int64_t btck_transaction_output_get_amount(const btck_TransactionOutput* output)
+{
+    return btck_TransactionOutput::get(output).nValue;
+}
+
+void btck_transaction_output_destroy(btck_TransactionOutput* output)
+{
+    delete output;
+}
+
+int btck_script_pubkey_verify(const btck_ScriptPubkey* script_pubkey,
+                              const int64_t amount,
+                              const btck_Transaction* tx_to,
+                              const btck_TransactionOutput** spent_outputs_, size_t spent_outputs_len,
+                              const unsigned int input_index,
+                              const btck_ScriptVerificationFlags flags,
+                              btck_ScriptVerifyStatus* status)
+{
+    // Assert that all specified flags are part of the interface before continuing
+    assert((flags & ~btck_ScriptVerificationFlags_ALL) == 0);
+
+    if (!is_valid_flag_combination(script_verify_flags::from_int(flags))) {
+        if (status) *status = btck_ScriptVerifyStatus_ERROR_INVALID_FLAGS_COMBINATION;
+        return 0;
+    }
+
+    if (flags & btck_ScriptVerificationFlags_TAPROOT && spent_outputs_ == nullptr) {
+        if (status) *status = btck_ScriptVerifyStatus_ERROR_SPENT_OUTPUTS_REQUIRED;
+        return 0;
+    }
+
+    const CTransaction& tx{*btck_Transaction::get(tx_to)};
+    std::vector<CTxOut> spent_outputs;
+    if (spent_outputs_ != nullptr) {
+        assert(spent_outputs_len == tx.vin.size());
+        spent_outputs.reserve(spent_outputs_len);
+        for (size_t i = 0; i < spent_outputs_len; i++) {
+            const CTxOut& tx_out{btck_TransactionOutput::get(spent_outputs_[i])};
+            spent_outputs.push_back(tx_out);
+        }
+    }
+
+    assert(input_index < tx.vin.size());
+    PrecomputedTransactionData txdata{tx};
+
+    if (spent_outputs_ != nullptr && flags & btck_ScriptVerificationFlags_TAPROOT) {
+        txdata.Init(tx, std::move(spent_outputs));
+    }
+
+    bool result = VerifyScript(tx.vin[input_index].scriptSig,
+                               btck_ScriptPubkey::get(script_pubkey),
+                               &tx.vin[input_index].scriptWitness,
+                               script_verify_flags::from_int(flags),
+                               TransactionSignatureChecker(&tx, input_index, amount, txdata, MissingDataBehavior::FAIL),
+                               nullptr);
+    return result ? 1 : 0;
+}
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
new file mode 100644
index 00000000000..8b2cfb3e722
--- /dev/null
+++ b/src/kernel/bitcoinkernel.h
@@ -0,0 +1,341 @@
+// Copyright (c) 2024-present The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_KERNEL_BITCOINKERNEL_H
+#define BITCOIN_KERNEL_BITCOINKERNEL_H
+
+#ifndef __cplusplus
+#include <stddef.h>
+#include <stdint.h>
+#else
+#include <cstddef>
+#include <cstdint>
+#endif // __cplusplus
+
+#ifndef BITCOINKERNEL_API
+    #ifdef BITCOINKERNEL_BUILD
+        #if defined(_WIN32)
+            #define BITCOINKERNEL_API __declspec(dllexport)
+        #else
+            #define BITCOINKERNEL_API __attribute__((visibility("default")))
+        #endif
+    #else
+        #if defined(_WIN32) && !defined(BITCOINKERNEL_STATIC)
+            #define BITCOINKERNEL_API __declspec(dllimport)
+        #else
+            #define BITCOINKERNEL_API
+        #endif
+    #endif
+#endif
+
+/* Warning attributes */
+#if defined(__GNUC__)
+    #define BITCOINKERNEL_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
+#else
+    #define BITCOINKERNEL_WARN_UNUSED_RESULT
+#endif
+#if !defined(BITCOINKERNEL_BUILD) && defined(__GNUC__)
+    #define BITCOINKERNEL_ARG_NONNULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
+#else
+    #define BITCOINKERNEL_ARG_NONNULL(...)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+/**
+ * @page remarks Remarks
+ *
+ * @section context Context
+ *
+ * The library provides a built-in static constant kernel context. This static
+ * context offers only limited functionality. It detects and self-checks the
+ * correct sha256 implementation, initializes the random number generator and
+ * self-checks the secp256k1 static context. It is used internally for
+ * otherwise "context-free" operations. This means that the user is not
+ * required to initialize their own context before using the library.
+ *
+ * @section error Error handling
+ *
+ * Functions communicate an error through their return types, usually returning
+ * a nullptr, 0, or false if an error is encountered. Additionally, verification
+ * functions, e.g. for scripts, may communicate more detailed error information
+ * through status code out parameters.
+ *
+ * @section pointer Pointer and argument conventions
+ *
+ * The user is responsible for de-allocating the memory owned by pointers
+ * returned by functions. Typically pointers returned by *_create(...) functions
+ * can be de-allocated by corresponding *_destroy(...) functions.
+ *
+ * A function that takes pointer arguments makes no assumptions on their
+ * lifetime. Once the function returns the user can safely de-allocate the
+ * passed in arguments.
+ *
+ * Const pointers represent views, and do not transfer ownership. Lifetime
+ * guarantees of these objects are described in the respective documentation.
+ * Ownership of these resources may be taken by copying. They are typically
+ * used for iteration with minimal overhead and require some care by the
+ * programmer that their lifetime is not extended beyond that of the original
+ * object.
+ *
+ * Array lengths follow the pointer argument they describe.
+ */
+
+/**
+ * Opaque data structure for holding a transaction.
+ */
+typedef struct btck_Transaction btck_Transaction;
+
+/**
+ * Opaque data structure for holding a script pubkey.
+ */
+typedef struct btck_ScriptPubkey btck_ScriptPubkey;
+
+/**
+ * Opaque data structure for holding a transaction output.
+ */
+typedef struct btck_TransactionOutput btck_TransactionOutput;
+
+/**
+ * A collection of status codes that may be issued by the script verify function.
+ */
+typedef uint8_t btck_ScriptVerifyStatus;
+#define btck_ScriptVerifyStatus_SCRIPT_VERIFY_OK ((btck_ScriptVerifyStatus)(0))
+#define btck_ScriptVerifyStatus_ERROR_INVALID_FLAGS_COMBINATION ((btck_ScriptVerifyStatus)(2)) //!< The flags were combined in an invalid way.
+#define btck_ScriptVerifyStatus_ERROR_SPENT_OUTPUTS_REQUIRED ((btck_ScriptVerifyStatus)(3))    //!< The taproot flag was set, so valid spent_outputs have to be provided.
+
+/**
+ * Script verification flags that may be composed with each other.
+ */
+typedef uint32_t btck_ScriptVerificationFlags;
+#define btck_ScriptVerificationFlags_NONE ((btck_ScriptVerificationFlags)(0))
+#define btck_ScriptVerificationFlags_P2SH ((btck_ScriptVerificationFlags)(1U << 0))                 //!< evaluate P2SH (BIP16) subscripts
+#define btck_ScriptVerificationFlags_DERSIG ((btck_ScriptVerificationFlags)(1U << 2))               //!< enforce strict DER (BIP66) compliance
+#define btck_ScriptVerificationFlags_NULLDUMMY ((btck_ScriptVerificationFlags)(1U << 4))            //!< enforce NULLDUMMY (BIP147)
+#define btck_ScriptVerificationFlags_CHECKLOCKTIMEVERIFY ((btck_ScriptVerificationFlags)(1U << 9))  //!< enable CHECKLOCKTIMEVERIFY (BIP65)
+#define btck_ScriptVerificationFlags_CHECKSEQUENCEVERIFY ((btck_ScriptVerificationFlags)(1U << 10)) //!< enable CHECKSEQUENCEVERIFY (BIP112)
+#define btck_ScriptVerificationFlags_WITNESS ((btck_ScriptVerificationFlags)(1U << 11))             //!< enable WITNESS (BIP141)
+#define btck_ScriptVerificationFlags_TAPROOT ((btck_ScriptVerificationFlags)(1U << 17))             //!< enable TAPROOT (BIPs 341 & 342)
+#define btck_ScriptVerificationFlags_ALL ((btck_ScriptVerificationFlags)(btck_ScriptVerificationFlags_P2SH |                \
+                                                                         btck_ScriptVerificationFlags_DERSIG |              \
+                                                                         btck_ScriptVerificationFlags_NULLDUMMY |           \
+                                                                         btck_ScriptVerificationFlags_CHECKLOCKTIMEVERIFY | \
+                                                                         btck_ScriptVerificationFlags_CHECKSEQUENCEVERIFY | \
+                                                                         btck_ScriptVerificationFlags_WITNESS |             \
+                                                                         btck_ScriptVerificationFlags_TAPROOT))
+
+/**
+ * Function signature for serializing data.
+ */
+typedef int (*btck_WriteBytes)(const void* bytes, size_t size, void* userdata);
+
+/** @name Transaction
+ * Functions for working with transactions.
+ */
+///@{
+
+/**
+ * @brief Create a new transaction from the serialized data.
+ *
+ * @param[in] raw_transaction     Non-null.
+ * @param[in] raw_transaction_len Length of the serialized transaction.
+ * @return                        The transaction, or null on error.
+ */
+BITCOINKERNEL_API btck_Transaction* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_create(
+    const void* raw_transaction, size_t raw_transaction_len) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Copy a transaction. Transactions are reference counted, so this just
+ * increments the reference count.
+ *
+ * @param[in] transaction Non-null.
+ * @return                The copied transaction.
+ */
+BITCOINKERNEL_API btck_Transaction* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_copy(
+    const btck_Transaction* transaction) BITCOINKERNEL_ARG_NONNULL(1);
+
+/*
+ * @brief Serializes the transaction through the passed in callback to bytes.
+ * This is consensus serialization that is also used for the p2p network.
+ *
+ * @param[in] transaction Non-null.
+ * @param[in] writer      Non-null, callback to a write bytes function.
+ * @param[in] user_data   Holds a user-defined opaque structure that will be
+ *                        passed back through the writer callback.
+ * @return                0 on success.
+ */
+BITCOINKERNEL_API int btck_transaction_to_bytes(
+    const btck_Transaction* transaction,
+    btck_WriteBytes writer,
+    void* user_data) BITCOINKERNEL_ARG_NONNULL(1, 2);
+
+/**
+ * @brief Get the number of outputs of a transaction.
+ *
+ * @param[in] transaction Non-null.
+ * @return                The number of outputs.
+ */
+BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_count_outputs(
+    const btck_Transaction* transaction) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Get the transaction outputs at the provided index. The returned
+ * transaction output is not owned and depends on the lifetime of the
+ * transaction.
+ *
+ * @param[in] transaction  Non-null.
+ * @param[in] output_index The index of the transaction to be retrieved.
+ * @return                 The transaction output
+ */
+BITCOINKERNEL_API const btck_TransactionOutput* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_get_output_at(
+    const btck_Transaction* transaction, size_t output_index) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Get the number of inputs of a transaction.
+ *
+ * @param[in] transaction Non-null.
+ * @return                The number of inputs.
+ */
+BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_count_inputs(
+    const btck_Transaction* transaction) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Destroy the transaction.
+ */
+BITCOINKERNEL_API void btck_transaction_destroy(btck_Transaction* transaction);
+
+///@}
+
+/** @name ScriptPubkey
+ * Functions for working with script pubkeys.
+ */
+///@{
+
+/**
+ * @brief Create a script pubkey from serialized data.
+ * @param[in] script_pubkey     Non-null.
+ * @param[in] script_pubkey_len Length of the script pubkey data.
+ * @return                      The script pubkey.
+ */
+BITCOINKERNEL_API btck_ScriptPubkey* BITCOINKERNEL_WARN_UNUSED_RESULT btck_script_pubkey_create(
+    const void* script_pubkey, size_t script_pubkey_len) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Copy a script pubkey.
+ *
+ * @param[in] script_pubkey Non-null.
+ * @return                  The copied script pubkey.
+ */
+BITCOINKERNEL_API btck_ScriptPubkey* BITCOINKERNEL_WARN_UNUSED_RESULT btck_script_pubkey_copy(
+    const btck_ScriptPubkey* script_pubkey) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Verify if the input at input_index of tx_to spends the script pubkey
+ * under the constraints specified by flags. If the
+ * `btck_SCRIPT_FLAGS_VERIFY_WITNESS` flag is set in the flags bitfield, the
+ * amount parameter is used. If the taproot flag is set, the spent outputs
+ * parameter is used to validate taproot transactions.
+ *
+ * @param[in] script_pubkey     Non-null, script pubkey to be spent.
+ * @param[in] amount            Amount of the script pubkey's associated output. May be zero if
+ *                              the witness flag is not set.
+ * @param[in] tx_to             Non-null, transaction spending the script_pubkey.
+ * @param[in] spent_outputs     Nullable if the taproot flag is not set. Points to an array of
+ *                              outputs spent by the transaction.
+ * @param[in] spent_outputs_len Length of the spent_outputs array.
+ * @param[in] input_index       Index of the input in tx_to spending the script_pubkey.
+ * @param[in] flags             Bitfield of btck_ScriptFlags controlling validation constraints.
+ * @param[out] status           Nullable, will be set to an error code if the operation fails.
+ *                              Should be set to btck_SCRIPT_VERIFY_OK.
+ * @return                      1 if the script is valid, 0 otherwise.
+ */
+BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_script_pubkey_verify(
+    const btck_ScriptPubkey* script_pubkey,
+    int64_t amount,
+    const btck_Transaction* tx_to,
+    const btck_TransactionOutput** spent_outputs, size_t spent_outputs_len,
+    unsigned int input_index,
+    unsigned int flags,
+    btck_ScriptVerifyStatus* status) BITCOINKERNEL_ARG_NONNULL(1, 3);
+
+/*
+ * @brief Serializes the script pubkey through the passed in callback to bytes.
+ *
+ * @param[in] script_pubkey Non-null.
+ * @param[in] writer        Non-null, callback to a write bytes function.
+ * @param[in] user_data     Holds a user-defined opaque structure that will be
+ *                          passed back through the writer callback.
+ * @return                  0 on success.
+ */
+BITCOINKERNEL_API int btck_script_pubkey_to_bytes(
+    const btck_ScriptPubkey* script_pubkey,
+    btck_WriteBytes writer,
+    void* user_data) BITCOINKERNEL_ARG_NONNULL(1, 2);
+
+/**
+ * Destroy the script pubkey.
+ */
+BITCOINKERNEL_API void btck_script_pubkey_destroy(btck_ScriptPubkey* script_pubkey);
+
+///@}
+
+/** @name TransactionOutput
+ * Functions for working with transaction outputs.
+ */
+///@{
+
+/**
+ * @brief Create a transaction output from a script pubkey and an amount.
+ *
+ * @param[in] script_pubkey Non-null.
+ * @param[in] amount        The amount associated with the script pubkey for this output.
+ * @return                  The transaction output.
+ */
+BITCOINKERNEL_API btck_TransactionOutput* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_output_create(
+    const btck_ScriptPubkey* script_pubkey,
+    int64_t amount) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Get the script pubkey of the output. The returned
+ * script pubkey is not owned and depends on the lifetime of the
+ * transaction output.
+ *
+ * @param[in] transaction_output Non-null.
+ * @return                       The script pubkey.
+ */
+BITCOINKERNEL_API const btck_ScriptPubkey* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_output_get_script_pubkey(
+    const btck_TransactionOutput* transaction_output) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Get the amount in the output.
+ *
+ * @param[in] transaction_output Non-null.
+ * @return                       The amount.
+ */
+BITCOINKERNEL_API int64_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_output_get_amount(
+    const btck_TransactionOutput* transaction_output) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ *  @brief Copy a transaction output.
+ *
+ *  @param[in] transaction_output Non-null.
+ *  @return                       The copied transaction output.
+ */
+BITCOINKERNEL_API btck_TransactionOutput* btck_transaction_output_copy(
+    const btck_TransactionOutput* transaction_output) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Destroy the transaction output.
+ */
+BITCOINKERNEL_API void btck_transaction_output_destroy(btck_TransactionOutput* transaction_output);
+
+///@}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
+
+#endif // BITCOIN_KERNEL_BITCOINKERNEL_H
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
new file mode 100644
index 00000000000..f621f3ac26e
--- /dev/null
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -0,0 +1,444 @@
+// Copyright (c) 2024-present The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_KERNEL_BITCOINKERNEL_WRAPPER_H
+#define BITCOIN_KERNEL_BITCOINKERNEL_WRAPPER_H
+
+#include <kernel/bitcoinkernel.h>
+
+#include <functional>
+#include <memory>
+#include <span>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace btck {
+
+class Transaction;
+class TransactionOutput;
+
+enum class ScriptVerifyStatus : btck_ScriptVerifyStatus {
+    OK = btck_ScriptVerifyStatus_SCRIPT_VERIFY_OK,
+    ERROR_INVALID_FLAGS_COMBINATION = btck_ScriptVerifyStatus_ERROR_INVALID_FLAGS_COMBINATION,
+    ERROR_SPENT_OUTPUTS_REQUIRED = btck_ScriptVerifyStatus_ERROR_SPENT_OUTPUTS_REQUIRED,
+};
+
+enum class ScriptVerificationFlags : btck_ScriptVerificationFlags {
+    NONE = btck_ScriptVerificationFlags_NONE,
+    P2SH = btck_ScriptVerificationFlags_P2SH,
+    DERSIG = btck_ScriptVerificationFlags_DERSIG,
+    NULLDUMMY = btck_ScriptVerificationFlags_NULLDUMMY,
+    CHECKLOCKTIMEVERIFY = btck_ScriptVerificationFlags_CHECKLOCKTIMEVERIFY,
+    CHECKSEQUENCEVERIFY = btck_ScriptVerificationFlags_CHECKSEQUENCEVERIFY,
+    WITNESS = btck_ScriptVerificationFlags_WITNESS,
+    TAPROOT = btck_ScriptVerificationFlags_TAPROOT,
+    ALL = btck_ScriptVerificationFlags_ALL
+};
+
+template <typename T>
+struct is_bitmask_enum : std::false_type {
+};
+
+template <>
+struct is_bitmask_enum<ScriptVerificationFlags> : std::true_type {
+};
+
+template <typename T>
+concept BitmaskEnum = is_bitmask_enum<T>::value;
+
+template <BitmaskEnum T>
+constexpr T operator|(T lhs, T rhs)
+{
+    return static_cast<T>(
+        static_cast<std::underlying_type_t<T>>(lhs) | static_cast<std::underlying_type_t<T>>(rhs));
+}
+
+template <BitmaskEnum T>
+constexpr T operator&(T lhs, T rhs)
+{
+    return static_cast<T>(
+        static_cast<std::underlying_type_t<T>>(lhs) & static_cast<std::underlying_type_t<T>>(rhs));
+}
+
+template <BitmaskEnum T>
+constexpr T operator^(T lhs, T rhs)
+{
+    return static_cast<T>(
+        static_cast<std::underlying_type_t<T>>(lhs) ^ static_cast<std::underlying_type_t<T>>(rhs));
+}
+
+template <BitmaskEnum T>
+constexpr T operator~(T value)
+{
+    return static_cast<T>(~static_cast<std::underlying_type_t<T>>(value));
+}
+
+template <BitmaskEnum T>
+constexpr T& operator|=(T& lhs, T rhs)
+{
+    return lhs = lhs | rhs;
+}
+
+template <BitmaskEnum T>
+constexpr T& operator&=(T& lhs, T rhs)
+{
+    return lhs = lhs & rhs;
+}
+
+template <BitmaskEnum T>
+constexpr T& operator^=(T& lhs, T rhs)
+{
+    return lhs = lhs ^ rhs;
+}
+
+template <typename T>
+T check(T ptr)
+{
+    if (ptr == nullptr) {
+        throw std::runtime_error("failed to instantiate btck object");
+    }
+    return ptr;
+}
+
+template <typename Collection, typename ValueType>
+class Iterator
+{
+public:
+    using iterator_category = std::random_access_iterator_tag;
+    using iterator_concept = std::random_access_iterator_tag;
+    using difference_type = std::ptrdiff_t;
+    using value_type = ValueType;
+
+private:
+    const Collection* m_collection;
+    size_t m_idx;
+
+public:
+    Iterator() = default;
+    Iterator(const Collection* ptr) : m_collection{ptr}, m_idx{0} {}
+    Iterator(const Collection* ptr, size_t idx) : m_collection{ptr}, m_idx{idx} {}
+
+    auto operator*() const { return (*m_collection)[m_idx]; }
+    auto operator->() const { return (*m_collection)[m_idx]; }
+
+    auto& operator++() { m_idx++; return *this; }
+    auto operator++(int) { Iterator tmp = *this; ++(*this); return tmp; }
+
+    auto& operator--() { m_idx--; return *this; }
+    auto operator--(int) { auto temp = *this; --m_idx; return temp; }
+
+    auto& operator+=(difference_type n) { m_idx += n; return *this; }
+    auto& operator-=(difference_type n) { m_idx -= n; return *this; }
+
+    auto operator+(difference_type n) const { return Iterator(m_collection, m_idx + n); }
+    auto operator-(difference_type n) const { return Iterator(m_collection, m_idx - n); }
+
+    auto operator-(const Iterator& other) const { return static_cast<difference_type>(m_idx) - static_cast<difference_type>(other.m_idx); }
+
+    ValueType operator[](difference_type n) const { return (*m_collection)[m_idx + n]; }
+
+    auto operator<=>(const Iterator& other) const { return m_idx <=> other.m_idx; }
+
+    bool operator==(const Iterator& other) const { return m_collection == other.m_collection && m_idx == other.m_idx; }
+
+private:
+    friend Iterator operator+(difference_type n, const Iterator& it) { return it + n; }
+};
+
+template <typename Container, typename SizeFunc, typename GetFunc>
+concept IndexedContainer = requires(const Container& c, SizeFunc size_func, GetFunc get_func, std::size_t i) {
+    { std::invoke(size_func, c) } -> std::convertible_to<std::size_t>;
+    { std::invoke(get_func, c, i) }; // Return type is deduced
+};
+
+template <typename Container, auto SizeFunc, auto GetFunc>
+    requires IndexedContainer<Container, decltype(SizeFunc), decltype(GetFunc)>
+class Range
+{
+public:
+    using value_type = std::invoke_result_t<decltype(GetFunc), const Container&, size_t>;
+    using difference_type = std::ptrdiff_t;
+    using iterator = Iterator<Range, value_type>;
+    using const_iterator = iterator;
+
+private:
+    const Container* m_container;
+
+public:
+    explicit Range(const Container& container) : m_container(&container)
+    {
+        static_assert(std::ranges::random_access_range<Range>);
+    }
+
+    iterator begin() const { return iterator(this, 0); }
+    iterator end() const { return iterator(this, size()); }
+
+    const_iterator cbegin() const { return begin(); }
+    const_iterator cend() const { return end(); }
+
+    size_t size() const { return std::invoke(SizeFunc, *m_container); }
+
+    bool empty() const { return size() == 0; }
+
+    value_type operator[](size_t index) const { return std::invoke(GetFunc, *m_container, index); }
+
+    value_type at(size_t index) const
+    {
+        if (index >= size()) {
+            throw std::out_of_range("Index out of range");
+        }
+        return (*this)[index];
+    }
+
+    value_type front() const { return (*this)[0]; }
+    value_type back() const { return (*this)[size() - 1]; }
+};
+
+template <typename T>
+std::vector<std::byte> write_bytes(const T* object, int (*to_bytes)(const T*, btck_WriteBytes, void*))
+{
+    std::vector<std::byte> bytes;
+    struct UserData {
+        std::vector<std::byte>* bytes;
+        std::exception_ptr exception;
+    };
+    UserData user_data = UserData{.bytes = &bytes, .exception = nullptr};
+
+    constexpr auto const write = +[](const void* buffer, size_t len, void* user_data) -> int {
+        auto& data = *reinterpret_cast<UserData*>(user_data);
+        auto& bytes = *data.bytes;
+        try {
+            auto const* first = static_cast<const std::byte*>(buffer);
+            auto const* last = first + len;
+            bytes.insert(bytes.end(), first, last);
+            return 0;
+        } catch (...) {
+            data.exception = std::current_exception();
+            return -1;
+        }
+    };
+
+    if (to_bytes(object, write, &user_data) != 0) {
+        std::rethrow_exception(user_data.exception);
+    }
+    return bytes;
+}
+
+template <typename CType>
+class View
+{
+protected:
+    const CType* m_ptr;
+
+public:
+    explicit View(const CType* ptr) : m_ptr{check(ptr)} {}
+
+    const CType* get() const { return m_ptr; }
+};
+
+template <typename CType, CType* (*CopyFunc)(const CType*), void (*DestroyFunc)(CType*)>
+class Handle
+{
+protected:
+    CType* m_ptr;
+
+public:
+    explicit Handle(CType* ptr) : m_ptr{check(ptr)} {}
+
+    // Copy constructors
+    Handle(const Handle& other)
+        : m_ptr{check(CopyFunc(other.m_ptr))} {}
+    Handle& operator=(const Handle& other)
+    {
+        if (this != &other) {
+            Handle temp(other);
+            std::swap(m_ptr, temp.m_ptr);
+        }
+        return *this;
+    }
+
+    // Move constructors
+    Handle(Handle&& other) noexcept : m_ptr(other.m_ptr) { other.m_ptr = nullptr; }
+    Handle& operator=(Handle&& other) noexcept
+    {
+        DestroyFunc(m_ptr);
+        m_ptr = std::exchange(other.m_ptr, nullptr);
+        return *this;
+    }
+
+    template <typename ViewType>
+        requires std::derived_from<ViewType, View<CType>>
+    Handle(const ViewType& view)
+        : Handle{CopyFunc(view.get())}
+    {
+    }
+
+    ~Handle() { DestroyFunc(m_ptr); }
+
+    CType* get() { return m_ptr; }
+    const CType* get() const { return m_ptr; }
+};
+
+class Transaction;
+class TransactionOutput;
+
+template <typename Derived>
+class ScriptPubkeyApi
+{
+private:
+    auto impl() const
+    {
+        return static_cast<const Derived*>(this)->get();
+    }
+
+    friend Derived;
+    ScriptPubkeyApi() = default;
+
+public:
+    bool Verify(int64_t amount,
+                const Transaction& tx_to,
+                std::span<const TransactionOutput> spent_outputs,
+                unsigned int input_index,
+                ScriptVerificationFlags flags,
+                ScriptVerifyStatus& status) const;
+
+    std::vector<std::byte> ToBytes() const
+    {
+        return write_bytes(impl(), btck_script_pubkey_to_bytes);
+    }
+};
+
+class ScriptPubkeyView : public View<btck_ScriptPubkey>, public ScriptPubkeyApi<ScriptPubkeyView>
+{
+public:
+    explicit ScriptPubkeyView(const btck_ScriptPubkey* ptr) : View{ptr} {}
+};
+
+class ScriptPubkey : public Handle<btck_ScriptPubkey, btck_script_pubkey_copy, btck_script_pubkey_destroy>, public ScriptPubkeyApi<ScriptPubkey>
+{
+public:
+    explicit ScriptPubkey(std::span<const std::byte> raw)
+        : Handle{btck_script_pubkey_create(raw.data(), raw.size())} {}
+
+    ScriptPubkey(const ScriptPubkeyView& view)
+        : Handle(view) {}
+};
+
+template <typename Derived>
+class TransactionOutputApi
+{
+private:
+    auto impl() const
+    {
+        return static_cast<const Derived*>(this)->get();
+    }
+
+    friend Derived;
+    TransactionOutputApi() = default;
+
+public:
+    int64_t Amount() const
+    {
+        return btck_transaction_output_get_amount(impl());
+    }
+
+    ScriptPubkeyView GetScriptPubkey() const
+    {
+        return ScriptPubkeyView{btck_transaction_output_get_script_pubkey(impl())};
+    }
+};
+
+class TransactionOutputView : public View<btck_TransactionOutput>, public TransactionOutputApi<TransactionOutputView>
+{
+public:
+    explicit TransactionOutputView(const btck_TransactionOutput* ptr) : View{ptr} {}
+};
+
+class TransactionOutput : public Handle<btck_TransactionOutput, btck_transaction_output_copy, btck_transaction_output_destroy>, public TransactionOutputApi<TransactionOutput>
+{
+public:
+    explicit TransactionOutput(const ScriptPubkey& script_pubkey, int64_t amount)
+        : Handle{btck_transaction_output_create(script_pubkey.get(), amount)} {}
+
+    TransactionOutput(const TransactionOutputView& view)
+        : Handle(view) {}
+};
+
+template <typename Derived>
+class TransactionApi
+{
+private:
+    auto impl() const
+    {
+        return static_cast<const Derived*>(this)->get();
+    }
+
+public:
+    size_t CountOutputs() const
+    {
+        return btck_transaction_count_outputs(impl());
+    }
+
+    size_t CountInputs() const
+    {
+        return btck_transaction_count_inputs(impl());
+    }
+
+    TransactionOutputView GetOutput(size_t index) const
+    {
+        return TransactionOutputView{btck_transaction_get_output_at(impl(), index)};
+    }
+
+    auto Outputs() const
+    {
+        return Range<Derived, &TransactionApi<Derived>::CountOutputs, &TransactionApi<Derived>::GetOutput>{*static_cast<const Derived*>(this)};
+    }
+
+    std::vector<std::byte> ToBytes() const
+    {
+        return write_bytes(impl(), btck_transaction_to_bytes);
+    }
+};
+
+class Transaction : public Handle<btck_Transaction, btck_transaction_copy, btck_transaction_destroy>, public TransactionApi<Transaction>
+{
+public:
+    explicit Transaction(std::span<const std::byte> raw_transaction)
+        : Handle{btck_transaction_create(raw_transaction.data(), raw_transaction.size())} {}
+};
+
+template <typename Derived>
+bool ScriptPubkeyApi<Derived>::Verify(int64_t amount,
+                                      const Transaction& tx_to,
+                                      const std::span<const TransactionOutput> spent_outputs,
+                                      unsigned int input_index,
+                                      ScriptVerificationFlags flags,
+                                      ScriptVerifyStatus& status) const
+{
+    const btck_TransactionOutput** spent_outputs_ptr = nullptr;
+    std::vector<const btck_TransactionOutput*> raw_spent_outputs;
+    if (spent_outputs.size() > 0) {
+        raw_spent_outputs.reserve(spent_outputs.size());
+
+        for (const auto& output : spent_outputs) {
+            raw_spent_outputs.push_back(output.get());
+        }
+        spent_outputs_ptr = raw_spent_outputs.data();
+    }
+    auto result = btck_script_pubkey_verify(
+        impl(),
+        amount,
+        tx_to.get(),
+        spent_outputs_ptr, spent_outputs.size(),
+        input_index,
+        static_cast<btck_ScriptVerificationFlags>(flags),
+        reinterpret_cast<btck_ScriptVerifyStatus*>(&status));
+    return result == 1;
+}
+
+} // namespace btck
+
+#endif // BITCOIN_KERNEL_BITCOINKERNEL_WRAPPER_H
diff --git a/src/test/kernel/CMakeLists.txt b/src/test/kernel/CMakeLists.txt
new file mode 100644
index 00000000000..17900bddeb4
--- /dev/null
+++ b/src/test/kernel/CMakeLists.txt
@@ -0,0 +1,16 @@
+add_executable(test_kernel
+    test_kernel.cpp
+)
+
+target_link_libraries(test_kernel
+  PRIVATE
+    core_interface
+    bitcoinkernel
+    Boost::headers
+)
+
+set_target_properties(test_kernel PROPERTIES
+  SKIP_BUILD_RPATH OFF
+)
+
+add_test(NAME test_kernel COMMAND test_kernel)
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
new file mode 100644
index 00000000000..3e881f823ca
--- /dev/null
+++ b/src/test/kernel/test_kernel.cpp
@@ -0,0 +1,350 @@
+// Copyright (c) 2024-present The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <kernel/bitcoinkernel.h>
+#include <kernel/bitcoinkernel_wrapper.h>
+
+#define BOOST_TEST_MODULE Bitcoin Kernel Test Suite
+#include <boost/test/included/unit_test.hpp>
+
+#include <charconv>
+#include <cstdint>
+#include <cstdlib>
+#include <iostream>
+#include <ranges>
+#include <span>
+#include <vector>
+
+using namespace btck;
+
+std::vector<std::byte> hex_string_to_byte_vec(std::string_view hex)
+{
+    std::vector<std::byte> bytes;
+    bytes.reserve(hex.length() / 2);
+
+    for (size_t i{0}; i < hex.length(); i += 2) {
+        uint8_t byte_value;
+        auto [ptr, ec] = std::from_chars(hex.data() + i, hex.data() + i + 2, byte_value, 16);
+
+        if (ec != std::errc{} || ptr != hex.data() + i + 2) {
+            throw std::invalid_argument("Invalid hex character");
+        }
+        bytes.push_back(static_cast<std::byte>(byte_value));
+    }
+    return bytes;
+}
+
+constexpr auto VERIFY_ALL_PRE_SEGWIT{ScriptVerificationFlags::P2SH | ScriptVerificationFlags::DERSIG |
+                                     ScriptVerificationFlags::NULLDUMMY | ScriptVerificationFlags::CHECKLOCKTIMEVERIFY |
+                                     ScriptVerificationFlags::CHECKSEQUENCEVERIFY};
+constexpr auto VERIFY_ALL_PRE_TAPROOT{VERIFY_ALL_PRE_SEGWIT | ScriptVerificationFlags::WITNESS};
+
+void check_equal(std::span<const std::byte> _actual, std::span<const std::byte> _expected, bool equal = true)
+{
+    std::span<const uint8_t> actual{reinterpret_cast<const unsigned char*>(_actual.data()), _actual.size()};
+    std::span<const uint8_t> expected{reinterpret_cast<const unsigned char*>(_expected.data()), _expected.size()};
+    BOOST_CHECK_EQUAL_COLLECTIONS(
+        actual.begin(), actual.end(),
+        expected.begin(), expected.end());
+}
+
+void run_verify_test(
+    const ScriptPubkey& spent_script_pubkey,
+    const Transaction& spending_tx,
+    std::span<TransactionOutput> spent_outputs,
+    int64_t amount,
+    unsigned int input_index,
+    bool taproot)
+{
+    auto status = ScriptVerifyStatus::OK;
+
+    if (taproot) {
+        BOOST_CHECK(spent_script_pubkey.Verify(
+            amount,
+            spending_tx,
+            spent_outputs,
+            input_index,
+            ScriptVerificationFlags::ALL,
+            status));
+        BOOST_CHECK(status == ScriptVerifyStatus::OK);
+    } else {
+        BOOST_CHECK(!spent_script_pubkey.Verify(
+            amount,
+            spending_tx,
+            spent_outputs,
+            input_index,
+            ScriptVerificationFlags::ALL,
+            status));
+        BOOST_CHECK(status == ScriptVerifyStatus::ERROR_SPENT_OUTPUTS_REQUIRED);
+        status = ScriptVerifyStatus::OK;
+    }
+
+    BOOST_CHECK(spent_script_pubkey.Verify(
+        amount,
+        spending_tx,
+        spent_outputs,
+        input_index,
+        VERIFY_ALL_PRE_TAPROOT,
+        status));
+    BOOST_CHECK(status == ScriptVerifyStatus::OK);
+
+    BOOST_CHECK(spent_script_pubkey.Verify(
+        0,
+        spending_tx,
+        spent_outputs,
+        input_index,
+        VERIFY_ALL_PRE_SEGWIT,
+        status));
+    BOOST_CHECK(status == ScriptVerifyStatus::OK);
+
+    status = ScriptVerifyStatus::OK;
+}
+
+template <typename T>
+concept HasToBytes = requires(T t) {
+    { t.ToBytes() } -> std::convertible_to<std::vector<std::byte>>;
+};
+
+template <typename T>
+void CheckHandle(T object, T distinct_object)
+{
+    BOOST_CHECK(object.get() != nullptr);
+    BOOST_CHECK(distinct_object.get() != nullptr);
+    BOOST_CHECK(object.get() != distinct_object.get());
+
+    if constexpr (HasToBytes<T>) {
+        BOOST_CHECK_NE(object.ToBytes().size(), distinct_object.ToBytes().size());
+    }
+
+    // Copy constructor
+    T object2(distinct_object);
+    BOOST_CHECK_NE(object.get(), object2.get());
+    if constexpr (HasToBytes<T>) {
+        BOOST_CHECK_NE(object.ToBytes().size(), object2.ToBytes().size());
+    }
+
+    // Copy assignment
+    T object3{distinct_object};
+    object2 = object3;
+    BOOST_CHECK_NE(object3.get(), object2.get());
+    if constexpr (HasToBytes<T>) {
+        BOOST_CHECK_NE(object.ToBytes().size(), object2.ToBytes().size());
+        check_equal(object3.ToBytes(), object2.ToBytes());
+    }
+
+    // Move constructor
+    auto* original_ptr = object2.get();
+    T object4{std::move(object2)};
+    BOOST_CHECK_EQUAL(object4.get(), original_ptr);
+    BOOST_CHECK_EQUAL(object2.get(), nullptr); // NOLINT(bugprone-use-after-move)
+    if constexpr (HasToBytes<T>) {
+        check_equal(object4.ToBytes(), object3.ToBytes());
+    }
+
+    // Move assignment
+    original_ptr = object4.get();
+    object2 = std::move(object4);
+    BOOST_CHECK_EQUAL(object2.get(), original_ptr);
+    BOOST_CHECK_EQUAL(object4.get(), nullptr); // NOLINT(bugprone-use-after-move)
+    if constexpr (HasToBytes<T>) {
+        check_equal(object2.ToBytes(), object3.ToBytes());
+    }
+}
+
+template <typename RangeType>
+    requires std::ranges::random_access_range<RangeType>
+void CheckRange(const RangeType& range, size_t expected_size)
+{
+    using value_type = std::ranges::range_value_t<RangeType>;
+
+    BOOST_CHECK_EQUAL(range.size(), expected_size);
+    BOOST_CHECK_EQUAL(range.empty(), (expected_size == 0));
+
+    BOOST_CHECK(range.begin() != range.end());
+    BOOST_CHECK_EQUAL(std::distance(range.begin(), range.end()), static_cast<std::ptrdiff_t>(expected_size));
+    BOOST_CHECK(range.cbegin() == range.begin());
+    BOOST_CHECK(range.cend() == range.end());
+
+    for (size_t i = 0; i < range.size(); ++i) {
+        BOOST_CHECK_EQUAL(range[i].get(), (*(range.begin() + i)).get());
+    }
+
+    BOOST_CHECK_NE(range.at(0).get(), range.at(expected_size - 1).get());
+    BOOST_CHECK_THROW(range.at(expected_size), std::out_of_range);
+
+    BOOST_CHECK_EQUAL(range.front().get(), range[0].get());
+    BOOST_CHECK_EQUAL(range.back().get(), range[expected_size - 1].get());
+
+    auto it = range.begin();
+    auto it_copy = it;
+    ++it;
+    BOOST_CHECK(it != it_copy);
+    --it;
+    BOOST_CHECK(it == it_copy);
+    it = range.begin();
+    auto old_it = it++;
+    BOOST_CHECK(old_it == range.begin());
+    BOOST_CHECK(it == range.begin() + 1);
+    old_it = it--;
+    BOOST_CHECK(old_it == range.begin() + 1);
+    BOOST_CHECK(it == range.begin());
+
+    it = range.begin();
+    it += 2;
+    BOOST_CHECK(it == range.begin() + 2);
+    it -= 2;
+    BOOST_CHECK(it == range.begin());
+
+    BOOST_CHECK(range.begin() < range.end());
+    BOOST_CHECK(range.begin() <= range.end());
+    BOOST_CHECK(range.end() > range.begin());
+    BOOST_CHECK(range.end() >= range.begin());
+    BOOST_CHECK(range.begin() == range.begin());
+
+    BOOST_CHECK_EQUAL(range.begin()[0].get(), range[0].get());
+
+    size_t count = 0;
+    for (auto rit = range.end(); rit != range.begin();) {
+        --rit;
+        ++count;
+    }
+    BOOST_CHECK_EQUAL(count, expected_size);
+
+    std::vector<value_type> collected;
+    for (const auto& elem : range) {
+        collected.push_back(elem);
+    }
+    BOOST_CHECK_EQUAL(collected.size(), expected_size);
+
+    BOOST_CHECK_EQUAL(std::ranges::size(range), expected_size);
+
+    it = range.begin();
+    auto it2 = 1 + it;
+    BOOST_CHECK(it2 == it + 1);
+}
+
+BOOST_AUTO_TEST_CASE(btck_transaction_tests)
+{
+    auto tx_data{hex_string_to_byte_vec("02000000013f7cebd65c27431a90bba7f796914fe8cc2ddfc3f2cbd6f7e5f2fc854534da95000000006b483045022100de1ac3bcdfb0332207c4a91f3832bd2c2915840165f876ab47c5f8996b971c3602201c6c053d750fadde599e6f5c4e1963df0f01fc0d97815e8157e3d59fe09ca30d012103699b464d1d8bc9e47d4fb1cdaa89a1c5783d68363c4dbc4b524ed3d857148617feffffff02836d3c01000000001976a914fc25d6d5c94003bf5b0c7b640a248e2c637fcfb088ac7ada8202000000001976a914fbed3d9b11183209a57999d54d59f67c019e756c88ac6acb0700")};
+    auto tx{Transaction{tx_data}};
+    auto tx_data_2{hex_string_to_byte_vec("02000000000101904f4ee5c87d20090b642f116e458cd6693292ad9ece23e72f15fb6c05b956210500000000fdffffff02e2010000000000002251200839a723933b56560487ec4d67dda58f09bae518ffa7e148313c5696ac837d9f10060000000000002251205826bcdae7abfb1c468204170eab00d887b61ab143464a4a09e1450bdc59a3340140f26e7af574e647355830772946356c27e7bbc773c5293688890f58983499581be84de40be7311a14e6d6422605df086620e75adae84ff06b75ce5894de5e994a00000000")};
+    auto tx2{Transaction{tx_data_2}};
+    CheckHandle(tx, tx2);
+
+    BOOST_CHECK_EQUAL(tx.CountOutputs(), 2);
+    BOOST_CHECK_EQUAL(tx.CountInputs(), 1);
+    auto broken_tx_data{std::span<std::byte>{tx_data.begin(), tx_data.begin() + 10}};
+    BOOST_CHECK_THROW(Transaction{broken_tx_data}, std::runtime_error);
+    auto output{tx.GetOutput(tx.CountOutputs() - 1)};
+    BOOST_CHECK_EQUAL(output.Amount(), 42130042);
+    auto script_pubkey{output.GetScriptPubkey()};
+    {
+        auto tx_new{Transaction{tx_data}};
+        // This is safe, because we now use copy assignment
+        TransactionOutput output = tx_new.GetOutput(tx_new.CountOutputs() - 1);
+        ScriptPubkey script = output.GetScriptPubkey();
+
+        TransactionOutputView output2 = tx_new.GetOutput(tx_new.CountOutputs() - 1);
+        BOOST_CHECK_NE(output.get(), output2.get());
+        BOOST_CHECK_EQUAL(output.Amount(), output2.Amount());
+        TransactionOutput output3 = output2;
+        BOOST_CHECK_NE(output3.get(), output2.get());
+        BOOST_CHECK_EQUAL(output3.Amount(), output2.Amount());
+
+        // Non-owned view
+        ScriptPubkeyView script2 = output.GetScriptPubkey();
+        BOOST_CHECK_NE(script.get(), script2.get());
+        check_equal(script.ToBytes(), script2.ToBytes());
+
+        // Non-owned to owned
+        ScriptPubkey script3 = script2;
+        BOOST_CHECK_NE(script3.get(), script2.get());
+        check_equal(script3.ToBytes(), script2.ToBytes());
+    }
+    BOOST_CHECK_EQUAL(output.Amount(), 42130042);
+
+    auto tx_roundtrip{Transaction{tx.ToBytes()}};
+    check_equal(tx_roundtrip.ToBytes(), tx_data);
+
+    // The following code is unsafe, but left here to show limitations of the
+    // API, because we preserve the output view beyond the lifetime of the
+    // transaction. The view type wrapper should make this clear to the user.
+    // auto get_output = [&]() -> TransactionOutputView {
+    //     auto tx{Transaction{tx_data}};
+    //     return tx.GetOutput(0);
+    // };
+    // auto output_new = get_output();
+    // BOOST_CHECK_EQUAL(output_new.Amount(), 20737411);
+
+    int64_t total_amount{0};
+    for (const auto output : tx.Outputs()) {
+        total_amount += output.Amount();
+    }
+    BOOST_CHECK_EQUAL(total_amount, 62867453);
+
+    auto amount = *(tx.Outputs() | std::ranges::views::filter([](const auto& output) {
+                        return output.Amount() == 42130042;
+                    }) |
+                    std::views::transform([](const auto& output) {
+                        return output.Amount();
+                    })).begin();
+    BOOST_REQUIRE(amount);
+    BOOST_CHECK_EQUAL(amount, 42130042);
+
+    CheckRange(tx.Outputs(), tx.CountOutputs());
+
+    ScriptPubkey script_pubkey_roundtrip{script_pubkey.ToBytes()};
+    check_equal(script_pubkey_roundtrip.ToBytes(), script_pubkey.ToBytes());
+}
+
+BOOST_AUTO_TEST_CASE(btck_script_pubkey)
+{
+    auto script_data{hex_string_to_byte_vec("76a9144bfbaf6afb76cc5771bc6404810d1cc041a6933988ac")};
+    std::vector<std::byte> script_data_2 = script_data;
+    script_data_2.push_back(std::byte{0x51});
+    ScriptPubkey script{script_data};
+    ScriptPubkey script2{script_data_2};
+    CheckHandle(script, script2);
+}
+
+BOOST_AUTO_TEST_CASE(btck_transaction_output)
+{
+    ScriptPubkey script{hex_string_to_byte_vec("76a9144bfbaf6afb76cc5771bc6404810d1cc041a6933988ac")};
+    TransactionOutput output{script, 1};
+    TransactionOutput output2{script, 2};
+    CheckHandle(output, output2);
+}
+
+BOOST_AUTO_TEST_CASE(btck_script_verify_tests)
+{
+    // Legacy transaction aca326a724eda9a461c10a876534ecd5ae7b27f10f26c3862fb996f80ea2d45d
+    run_verify_test(
+        /*spent_script_pubkey*/ ScriptPubkey{hex_string_to_byte_vec("76a9144bfbaf6afb76cc5771bc6404810d1cc041a6933988ac")},
+        /*spending_tx*/ Transaction{hex_string_to_byte_vec("02000000013f7cebd65c27431a90bba7f796914fe8cc2ddfc3f2cbd6f7e5f2fc854534da95000000006b483045022100de1ac3bcdfb0332207c4a91f3832bd2c2915840165f876ab47c5f8996b971c3602201c6c053d750fadde599e6f5c4e1963df0f01fc0d97815e8157e3d59fe09ca30d012103699b464d1d8bc9e47d4fb1cdaa89a1c5783d68363c4dbc4b524ed3d857148617feffffff02836d3c01000000001976a914fc25d6d5c94003bf5b0c7b640a248e2c637fcfb088ac7ada8202000000001976a914fbed3d9b11183209a57999d54d59f67c019e756c88ac6acb0700")},
+        /*spent_outputs*/ {},
+        /*amount*/ 0,
+        /*input_index*/ 0,
+        /*is_taproot*/ false);
+
+    // Segwit transaction 1a3e89644985fbbb41e0dcfe176739813542b5937003c46a07de1e3ee7a4a7f3
+    run_verify_test(
+        /*spent_script_pubkey*/ ScriptPubkey{hex_string_to_byte_vec("0020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d")},
+        /*spending_tx*/ Transaction{hex_string_to_byte_vec("010000000001011f97548fbbe7a0db7588a66e18d803d0089315aa7d4cc28360b6ec50ef36718a0100000000ffffffff02df1776000000000017a9146c002a686959067f4866b8fb493ad7970290ab728757d29f0000000000220020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d04004730440220565d170eed95ff95027a69b313758450ba84a01224e1f7f130dda46e94d13f8602207bdd20e307f062594022f12ed5017bbf4a055a06aea91c10110a0e3bb23117fc014730440220647d2dc5b15f60bc37dc42618a370b2a1490293f9e5c8464f53ec4fe1dfe067302203598773895b4b16d37485cbe21b337f4e4b650739880098c592553add7dd4355016952210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae00000000")},
+        /*spent_outputs*/ {},
+        /*amount*/ 18393430,
+        /*input_index*/ 0,
+        /*is_taproot*/ false);
+
+    // Taproot transaction 33e794d097969002ee05d336686fc03c9e15a597c1b9827669460fac98799036
+    auto taproot_spent_script_pubkey{ScriptPubkey{hex_string_to_byte_vec("5120339ce7e165e67d93adb3fef88a6d4beed33f01fa876f05a225242b82a631abc0")}};
+    std::vector<TransactionOutput> spent_outputs;
+    spent_outputs.emplace_back(taproot_spent_script_pubkey, 88480);
+    run_verify_test(
+        /*spent_script_pubkey*/ taproot_spent_script_pubkey,
+        /*spending_tx*/ Transaction{hex_string_to_byte_vec("01000000000101d1f1c1f8cdf6759167b90f52c9ad358a369f95284e841d7a2536cef31c0549580100000000fdffffff020000000000000000316a2f49206c696b65205363686e6f7272207369677320616e6420492063616e6e6f74206c69652e204062697462756734329e06010000000000225120a37c3903c8d0db6512e2b40b0dffa05e5a3ab73603ce8c9c4b7771e5412328f90140a60c383f71bac0ec919b1d7dbc3eb72dd56e7aa99583615564f9f99b8ae4e837b758773a5b2e4c51348854c8389f008e05029db7f464a5ff2e01d5e6e626174affd30a00")},
+        /*spent_outputs*/ spent_outputs,
+        /*amount*/ 88480,
+        /*input_index*/ 0,
+        /*is_taproot*/ true);
+}

From 4a0f6ba7a7cfe5155c070f9b92d81404a9caa899 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Wed, 29 May 2024 16:13:45 +0200
Subject: [PATCH 02/24] kernel: Add logging to kernel library C header

Exposing logging in the kernel library allows users to follow
operations. Users of the C header can use
`kernel_logging_connection_create(...)` to pass a callback function to
Bitcoin Core's internal logger. Additionally the level and category can
be globally configured.

By default, the logger buffers messages until
`kernel_loggin_connection_create(...)` is called. If the user does not
want any logging messages, it is recommended that
`kernel_disable_logging()` is called, which permanently disables the
logging and any buffering of messages.
---
 src/kernel/bitcoinkernel.cpp       | 157 +++++++++++++++++++++++++++++
 src/kernel/bitcoinkernel.h         | 136 +++++++++++++++++++++++++
 src/kernel/bitcoinkernel_wrapper.h |  79 +++++++++++++++
 src/logging.cpp                    |   1 +
 src/logging.h                      |  12 +++
 src/test/kernel/test_kernel.cpp    |  36 +++++++
 6 files changed, 421 insertions(+)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index 4a6b254be23..05018c8113c 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -8,17 +8,22 @@
 
 #include <consensus/amount.h>
 #include <kernel/context.h>
+#include <kernel/cs_main.h>
+#include <logging.h>
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
 #include <script/script.h>
 #include <serialize.h>
 #include <streams.h>
+#include <tinyformat.h>
 #include <util/translation.h>
 
+#include <cassert>
 #include <cstddef>
 #include <cstring>
 #include <exception>
 #include <functional>
+#include <list>
 #include <span>
 #include <string>
 #include <utility>
@@ -103,11 +108,125 @@ struct Handle {
     }
 };
 
+BCLog::Level get_bclog_level(btck_LogLevel level)
+{
+    switch (level) {
+    case btck_LogLevel_INFO: {
+        return BCLog::Level::Info;
+    }
+    case btck_LogLevel_DEBUG: {
+        return BCLog::Level::Debug;
+    }
+    case btck_LogLevel_TRACE: {
+        return BCLog::Level::Trace;
+    }
+    }
+    assert(false);
+}
+
+BCLog::LogFlags get_bclog_flag(btck_LogCategory category)
+{
+    switch (category) {
+    case btck_LogCategory_BENCH: {
+        return BCLog::LogFlags::BENCH;
+    }
+    case btck_LogCategory_BLOCKSTORAGE: {
+        return BCLog::LogFlags::BLOCKSTORAGE;
+    }
+    case btck_LogCategory_COINDB: {
+        return BCLog::LogFlags::COINDB;
+    }
+    case btck_LogCategory_LEVELDB: {
+        return BCLog::LogFlags::LEVELDB;
+    }
+    case btck_LogCategory_MEMPOOL: {
+        return BCLog::LogFlags::MEMPOOL;
+    }
+    case btck_LogCategory_PRUNE: {
+        return BCLog::LogFlags::PRUNE;
+    }
+    case btck_LogCategory_RAND: {
+        return BCLog::LogFlags::RAND;
+    }
+    case btck_LogCategory_REINDEX: {
+        return BCLog::LogFlags::REINDEX;
+    }
+    case btck_LogCategory_VALIDATION: {
+        return BCLog::LogFlags::VALIDATION;
+    }
+    case btck_LogCategory_KERNEL: {
+        return BCLog::LogFlags::KERNEL;
+    }
+    case btck_LogCategory_ALL: {
+        return BCLog::LogFlags::ALL;
+    }
+    }
+    assert(false);
+}
+
+struct LoggingConnection {
+    std::unique_ptr<std::list<std::function<void(const std::string&)>>::iterator> m_connection;
+    void* m_user_data;
+    std::function<void(void* user_data)> m_deleter;
+
+    LoggingConnection(btck_LogCallback callback, void* user_data, btck_DestroyCallback user_data_destroy_callback, const btck_LoggingOptions options)
+    {
+        LOCK(cs_main);
+
+        LogInstance().m_log_timestamps = options.log_timestamps;
+        LogInstance().m_log_time_micros = options.log_time_micros;
+        LogInstance().m_log_threadnames = options.log_threadnames;
+        LogInstance().m_log_sourcelocations = options.log_sourcelocations;
+        LogInstance().m_always_print_category_level = options.always_print_category_levels;
+
+        auto connection{LogInstance().PushBackCallback([callback, user_data](const std::string& str) { callback(user_data, str.c_str(), str.length()); })};
+
+        try {
+            // Only start logging if we just added the connection.
+            if (LogInstance().NumConnections() == 1 && !LogInstance().StartLogging()) {
+                LogError("Logger start failed.");
+                LogInstance().DeleteCallback(connection);
+                user_data_destroy_callback(user_data);
+            }
+        } catch (std::exception& e) {
+            LogError("Logger start failed: %s", e.what());
+            LogInstance().DeleteCallback(connection);
+            user_data_destroy_callback(user_data);
+            throw;
+        }
+
+        m_connection = std::make_unique<std::list<std::function<void(const std::string&)>>::iterator>(connection);
+        m_user_data = user_data;
+        m_deleter = user_data_destroy_callback;
+
+        LogDebug(BCLog::KERNEL, "Logger connected.");
+    }
+
+    ~LoggingConnection()
+    {
+        LOCK(cs_main);
+
+        LogDebug(BCLog::KERNEL, "Logger disconnected.");
+        LogInstance().DeleteCallback(*m_connection);
+        m_connection.reset();
+        if (m_user_data && m_deleter) {
+            m_deleter(m_user_data);
+        }
+
+        // Switch back to buffering by calling DisconnectTestLogger if the
+        // connection that was just removed was the last one.
+        if (!LogInstance().Enabled()) {
+            LogInstance().DisconnectTestLogger();
+        }
+    }
+};
+
 } // namespace
 
 struct btck_Transaction : Handle<btck_Transaction, std::shared_ptr<const CTransaction>> {};
 struct btck_TransactionOutput : Handle<btck_TransactionOutput, CTxOut> {};
 struct btck_ScriptPubkey : Handle<btck_ScriptPubkey, CScript> {};
+struct btck_LoggingConnection : Handle<btck_LoggingConnection, LoggingConnection> {};
 
 btck_Transaction* btck_transaction_create(const void* raw_transaction, size_t raw_transaction_len)
 {
@@ -251,3 +370,41 @@ int btck_script_pubkey_verify(const btck_ScriptPubkey* script_pubkey,
                                nullptr);
     return result ? 1 : 0;
 }
+
+void btck_logging_set_level_category(btck_LogCategory category, btck_LogLevel level)
+{
+    LOCK(cs_main);
+    if (category == btck_LogCategory_ALL) {
+        LogInstance().SetLogLevel(get_bclog_level(level));
+    }
+
+    LogInstance().AddCategoryLogLevel(get_bclog_flag(category), get_bclog_level(level));
+}
+
+void btck_logging_enable_category(btck_LogCategory category)
+{
+    LogInstance().EnableCategory(get_bclog_flag(category));
+}
+
+void btck_logging_disable_category(btck_LogCategory category)
+{
+    LogInstance().DisableCategory(get_bclog_flag(category));
+}
+
+void btck_logging_disable()
+{
+    LogInstance().DisableLogging();
+}
+
+btck_LoggingConnection* btck_logging_connection_create(btck_LogCallback callback,
+                                                       void* user_data,
+                                                       btck_DestroyCallback user_data_destroy_callback,
+                                                       const btck_LoggingOptions options)
+{
+    return btck_LoggingConnection::create(callback, user_data, user_data_destroy_callback, options);
+}
+
+void btck_logging_connection_destroy(btck_LoggingConnection* connection)
+{
+    delete connection;
+}
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index 8b2cfb3e722..1bdf56d77b3 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -99,6 +99,69 @@ typedef struct btck_ScriptPubkey btck_ScriptPubkey;
  */
 typedef struct btck_TransactionOutput btck_TransactionOutput;
 
+/**
+ * Opaque data structure for holding a logging connection.
+ *
+ * The logging connection can be used to manually stop logging.
+ *
+ * Messages that were logged before a connection is created are buffered in a
+ * 1MB buffer. Logging can alternatively be permanently disabled by calling
+ * @ref btck_logging_disable. Functions changing the logging settings are
+ * global and change the settings for all existing btck_LoggingConnection
+ * instances.
+ */
+typedef struct btck_LoggingConnection btck_LoggingConnection;
+
+/** Callback function types */
+
+/**
+ * Function signature for the global logging callback. All bitcoin kernel
+ * internal logs will pass through this callback.
+ */
+typedef void (*btck_LogCallback)(void* user_data, const char* message, size_t message_len);
+
+/**
+ * Function signature for freeing user data.
+ */
+typedef void (*btck_DestroyCallback)(void* user_data);
+
+/**
+ * A collection of logging categories that may be encountered by kernel code.
+ */
+typedef uint8_t btck_LogCategory;
+#define btck_LogCategory_ALL ((btck_LogCategory)(0))
+#define btck_LogCategory_BENCH ((btck_LogCategory)(1))
+#define btck_LogCategory_BLOCKSTORAGE ((btck_LogCategory)(2))
+#define btck_LogCategory_COINDB ((btck_LogCategory)(3))
+#define btck_LogCategory_LEVELDB ((btck_LogCategory)(4))
+#define btck_LogCategory_MEMPOOL ((btck_LogCategory)(5))
+#define btck_LogCategory_PRUNE ((btck_LogCategory)(6))
+#define btck_LogCategory_RAND ((btck_LogCategory)(7))
+#define btck_LogCategory_REINDEX ((btck_LogCategory)(8))
+#define btck_LogCategory_VALIDATION ((btck_LogCategory)(9))
+#define btck_LogCategory_KERNEL ((btck_LogCategory)(10))
+
+/**
+ * The level at which logs should be produced.
+ */
+typedef uint8_t btck_LogLevel;
+#define btck_LogLevel_TRACE ((btck_LogLevel)(0))
+#define btck_LogLevel_DEBUG ((btck_LogLevel)(1))
+#define btck_LogLevel_INFO ((btck_LogLevel)(2))
+
+/**
+ * Options controlling the format of log messages.
+ *
+ * Set fields as non-zero to indicate true.
+ */
+typedef struct {
+    int log_timestamps;               //!< Prepend a timestamp to log messages.
+    int log_time_micros;              //!< Log timestamps in microsecond precision.
+    int log_threadnames;              //!< Prepend the name of the thread to log messages.
+    int log_sourcelocations;          //!< Prepend the source location to log messages.
+    int always_print_category_levels; //!< Prepend the log category and level to log messages.
+} btck_LoggingOptions;
+
 /**
  * A collection of status codes that may be issued by the script verify function.
  */
@@ -334,6 +397,79 @@ BITCOINKERNEL_API void btck_transaction_output_destroy(btck_TransactionOutput* t
 
 ///@}
 
+/** @name Logging
+ * Logging-related functions.
+ */
+///@{
+
+/**
+ * @brief This disables the global internal logger. No log messages will be
+ * buffered internally anymore once this is called and the buffer is cleared.
+ * This function should only be called once and is not thread or re-entry safe.
+ * Log messages will be buffered until this function is called, or a logging
+ * connection is created.
+ */
+BITCOINKERNEL_API void btck_logging_disable();
+
+/**
+ * @brief Set the log level of the global internal logger. This does not
+ * enable the selected categories. Use @ref btck_logging_enable_category to
+ * start logging from a specific, or all categories. This changes a global
+ * setting and will override settings for all existing
+ * @ref btck_LoggingConnection instances.
+ *
+ * @param[in] category If btck_LOG_ALL is chosen, all messages at the specified level
+ *                     will be logged. Otherwise only messages from the specified category
+ *                     will be logged at the specified level and above.
+ * @param[in] level    Log level at which the log category is set.
+ */
+BITCOINKERNEL_API void btck_logging_set_level_category(btck_LogCategory category, btck_LogLevel level);
+
+/**
+ * @brief Enable a specific log category for the global internal logger. This
+ * changes a global setting and will override settings for all existing @ref
+ * btck_LoggingConnection instances.
+ *
+ * @param[in] category If btck_LOG_ALL is chosen, all categories will be enabled.
+ */
+BITCOINKERNEL_API void btck_logging_enable_category(btck_LogCategory category);
+
+/**
+ * @brief Disable a specific log category for the global internal logger. This
+ * changes a global setting and will override settings for all existing @ref
+ * btck_LoggingConnection instances.
+ *
+ * @param[in] category If btck_LOG_ALL is chosen, all categories will be disabled.
+ */
+BITCOINKERNEL_API void btck_logging_disable_category(btck_LogCategory category);
+
+/**
+ * @brief Start logging messages through the provided callback. Log messages
+ * produced before this function is first called are buffered and on calling this
+ * function are logged immediately.
+ *
+ * @param[in] log_callback               Non-null, function through which messages will be logged.
+ * @param[in] user_data                  Nullable, holds a user-defined opaque structure. Is passed back
+ *                                       to the user through the callback. If the user_data_destroy_callback
+ *                                       is also defined it is assumed that ownership of the user_data is passed
+ *                                       to the created logging connection.
+ * @param[in] user_data_destroy_callback Nullable, function for freeing the user data.
+ * @param[in] options                    Sets formatting options of the log messages.
+ * @return                               A new kernel logging connection, or null on error.
+ */
+BITCOINKERNEL_API btck_LoggingConnection* BITCOINKERNEL_WARN_UNUSED_RESULT btck_logging_connection_create(
+    btck_LogCallback log_callback,
+    void* user_data,
+    btck_DestroyCallback user_data_destroy_callback,
+    const btck_LoggingOptions options) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Stop logging and destroy the logging connection.
+ */
+BITCOINKERNEL_API void btck_logging_connection_destroy(btck_LoggingConnection* logging_connection);
+
+///@}
+
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index f621f3ac26e..f3a235f2ba0 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -11,6 +11,7 @@
 #include <memory>
 #include <span>
 #include <stdexcept>
+#include <string_view>
 #include <type_traits>
 #include <utility>
 #include <vector>
@@ -20,6 +21,26 @@ namespace btck {
 class Transaction;
 class TransactionOutput;
 
+enum class LogCategory : btck_LogCategory {
+    ALL = btck_LogCategory_ALL,
+    BENCH = btck_LogCategory_BENCH,
+    BLOCKSTORAGE = btck_LogCategory_BLOCKSTORAGE,
+    COINDB = btck_LogCategory_COINDB,
+    LEVELDB = btck_LogCategory_LEVELDB,
+    MEMPOOL = btck_LogCategory_MEMPOOL,
+    PRUNE = btck_LogCategory_PRUNE,
+    RAND = btck_LogCategory_RAND,
+    REINDEX = btck_LogCategory_REINDEX,
+    VALIDATION = btck_LogCategory_VALIDATION,
+    KERNEL = btck_LogCategory_KERNEL
+};
+
+enum class LogLevel : btck_LogLevel {
+    TRACE_LEVEL = btck_LogLevel_TRACE,
+    DEBUG_LEVEL = btck_LogLevel_DEBUG,
+    INFO_LEVEL = btck_LogLevel_INFO
+};
+
 enum class ScriptVerifyStatus : btck_ScriptVerifyStatus {
     OK = btck_ScriptVerifyStatus_SCRIPT_VERIFY_OK,
     ERROR_INVALID_FLAGS_COMBINATION = btck_ScriptVerifyStatus_ERROR_INVALID_FLAGS_COMBINATION,
@@ -282,6 +303,25 @@ public:
     const CType* get() const { return m_ptr; }
 };
 
+template <typename CType, void (*DestroyFunc)(CType*)>
+class UniqueHandle
+{
+protected:
+    struct Deleter {
+        void operator()(CType* ptr) const noexcept
+        {
+            if (ptr) DestroyFunc(ptr);
+        }
+    };
+    std::unique_ptr<CType, Deleter> m_ptr;
+
+public:
+    explicit UniqueHandle(CType* ptr) : m_ptr{check(ptr)} {}
+
+    CType* get() { return m_ptr; }
+    const CType* get() const { return m_ptr; }
+};
+
 class Transaction;
 class TransactionOutput;
 
@@ -439,6 +479,45 @@ bool ScriptPubkeyApi<Derived>::Verify(int64_t amount,
     return result == 1;
 }
 
+void logging_disable()
+{
+    btck_logging_disable();
+}
+
+void logging_set_level_category(LogCategory category, LogLevel level)
+{
+    btck_logging_set_level_category(static_cast<btck_LogCategory>(category), static_cast<btck_LogLevel>(level));
+}
+
+void logging_enable_category(LogCategory category)
+{
+    btck_logging_enable_category(static_cast<btck_LogCategory>(category));
+}
+
+void logging_disable_category(LogCategory category)
+{
+    btck_logging_disable_category(static_cast<btck_LogCategory>(category));
+}
+
+template <typename T>
+concept Log = requires(T a, std::string_view message) {
+    { a.LogMessage(message) } -> std::same_as<void>;
+};
+
+template <Log T>
+class Logger : public UniqueHandle<btck_LoggingConnection, btck_logging_connection_destroy>
+{
+public:
+    Logger(std::unique_ptr<T> log, const btck_LoggingOptions& logging_options)
+        : UniqueHandle{btck_logging_connection_create(
+              +[](void* user_data, const char* message, size_t message_len) { static_cast<T*>(user_data)->LogMessage({message, message_len}); },
+              log.release(),
+              +[](void* user_data) { delete static_cast<T*>(user_data); },
+              logging_options)}
+    {
+    }
+};
+
 } // namespace btck
 
 #endif // BITCOIN_KERNEL_BITCOINKERNEL_WRAPPER_H
diff --git a/src/logging.cpp b/src/logging.cpp
index 2ed6835197b..f9d8f980488 100644
--- a/src/logging.cpp
+++ b/src/logging.cpp
@@ -201,6 +201,7 @@ static const std::map<std::string, BCLog::LogFlags, std::less<>> LOG_CATEGORIES_
     {"txreconciliation", BCLog::TXRECONCILIATION},
     {"scan", BCLog::SCAN},
     {"txpackages", BCLog::TXPACKAGES},
+    {"kernel", BCLog::KERNEL},
 };
 
 static const std::unordered_map<BCLog::LogFlags, std::string> LOG_CATEGORIES_BY_FLAG{
diff --git a/src/logging.h b/src/logging.h
index 723aeb790fb..defff61d300 100644
--- a/src/logging.h
+++ b/src/logging.h
@@ -94,6 +94,7 @@ namespace BCLog {
         TXRECONCILIATION = (CategoryMask{1} << 26),
         SCAN        = (CategoryMask{1} << 27),
         TXPACKAGES  = (CategoryMask{1} << 28),
+        KERNEL      = (CategoryMask{1} << 29),
         ALL         = ~NONE,
     };
     enum class Level {
@@ -256,6 +257,12 @@ namespace BCLog {
             m_print_callbacks.erase(it);
         }
 
+        size_t NumConnections()
+        {
+            StdLockGuard scoped_lock(m_cs);
+            return m_print_callbacks.size();
+        }
+
         /** Start logging (and flush all buffered messages) */
         bool StartLogging() EXCLUSIVE_LOCKS_REQUIRED(!m_cs);
         /** Only for testing */
@@ -287,6 +294,11 @@ namespace BCLog {
             StdLockGuard scoped_lock(m_cs);
             m_category_log_levels = levels;
         }
+        void AddCategoryLogLevel(LogFlags category, Level level)
+        {
+            StdLockGuard scoped_lock(m_cs);
+            m_category_log_levels[category] = level;
+        }
         bool SetCategoryLogLevel(std::string_view category_str, std::string_view level_str) EXCLUSIVE_LOCKS_REQUIRED(!m_cs);
 
         Level LogLevel() const { return m_log_level.load(); }
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index 3e881f823ca..5c935db088b 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -12,8 +12,10 @@
 #include <cstdint>
 #include <cstdlib>
 #include <iostream>
+#include <memory>
 #include <ranges>
 #include <span>
+#include <string_view>
 #include <vector>
 
 using namespace btck;
@@ -49,6 +51,15 @@ void check_equal(std::span<const std::byte> _actual, std::span<const std::byte>
         expected.begin(), expected.end());
 }
 
+class TestLog
+{
+public:
+    void LogMessage(std::string_view message)
+    {
+        std::cout << "kernel: " << message;
+    }
+};
+
 void run_verify_test(
     const ScriptPubkey& spent_script_pubkey,
     const Transaction& spending_tx,
@@ -348,3 +359,28 @@ BOOST_AUTO_TEST_CASE(btck_script_verify_tests)
         /*input_index*/ 0,
         /*is_taproot*/ true);
 }
+
+BOOST_AUTO_TEST_CASE(logging_tests)
+{
+    btck_LoggingOptions logging_options = {
+        .log_timestamps = true,
+        .log_time_micros = true,
+        .log_threadnames = false,
+        .log_sourcelocations = false,
+        .always_print_category_levels = true,
+    };
+
+    logging_set_level_category(LogCategory::BENCH, LogLevel::TRACE_LEVEL);
+    logging_disable_category(LogCategory::BENCH);
+    logging_enable_category(LogCategory::VALIDATION);
+    logging_disable_category(LogCategory::VALIDATION);
+
+    // Check that connecting, connecting another, and then disconnecting and connecting a logger again works.
+    {
+        logging_set_level_category(LogCategory::KERNEL, LogLevel::TRACE_LEVEL);
+        logging_enable_category(LogCategory::KERNEL);
+        Logger logger{std::make_unique<TestLog>(TestLog{}), logging_options};
+        Logger logger_2{std::make_unique<TestLog>(TestLog{}), logging_options};
+    }
+    Logger logger{std::make_unique<TestLog>(TestLog{}), logging_options};
+}

From cc89fcc6da4b37a510b5964803252ab798e6ae05 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Mon, 3 Jun 2024 14:35:47 +0200
Subject: [PATCH 03/24] kernel: Add kernel library context object

The context introduced here holds the objects that will be required for
running validation tasks, such as the chosen chain parameters, callbacks
for validation events, and interrupt handling. These will be used by the
chainstate manager introduced in subsequent commits.

This commit also introduces conventions for defining option objects. A
common pattern throughout the C header will be:
```
options = object_option_create();
object = object_create(options);
```
This allows for more consistent usage of a "builder pattern" for
objects where options can be configured independently from
instantiation.
---
 src/kernel/bitcoinkernel.cpp       | 66 +++++++++++++++++++++++++++
 src/kernel/bitcoinkernel.h         | 73 ++++++++++++++++++++++++++++++
 src/kernel/bitcoinkernel_wrapper.h | 24 ++++++++--
 src/test/kernel/test_kernel.cpp    | 14 ++++++
 4 files changed, 174 insertions(+), 3 deletions(-)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index 05018c8113c..180cf1e823e 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -7,8 +7,11 @@
 #include <kernel/bitcoinkernel.h>
 
 #include <consensus/amount.h>
+#include <kernel/chainparams.h>
+#include <kernel/checks.h>
 #include <kernel/context.h>
 #include <kernel/cs_main.h>
+#include <kernel/notifications_interface.h>
 #include <logging.h>
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
@@ -16,6 +19,8 @@
 #include <serialize.h>
 #include <streams.h>
 #include <tinyformat.h>
+#include <util/result.h>
+#include <util/signalinterrupt.h>
 #include <util/translation.h>
 
 #include <cassert>
@@ -24,6 +29,7 @@
 #include <exception>
 #include <functional>
 #include <list>
+#include <memory>
 #include <span>
 #include <string>
 #include <utility>
@@ -221,12 +227,40 @@ struct LoggingConnection {
     }
 };
 
+struct ContextOptions {
+};
+
+class Context
+{
+public:
+    std::unique_ptr<kernel::Context> m_context;
+
+    std::unique_ptr<kernel::Notifications> m_notifications;
+
+    std::unique_ptr<util::SignalInterrupt> m_interrupt;
+
+    std::unique_ptr<const CChainParams> m_chainparams;
+
+    Context(const ContextOptions* options, bool& sane)
+        : m_context{std::make_unique<kernel::Context>()},
+          m_notifications{std::make_unique<kernel::Notifications>()},
+          m_interrupt{std::make_unique<util::SignalInterrupt>()},
+          m_chainparams{CChainParams::Main()}
+    {
+        if (!kernel::SanityChecks(*m_context)) {
+            sane = false;
+        }
+    }
+};
+
 } // namespace
 
 struct btck_Transaction : Handle<btck_Transaction, std::shared_ptr<const CTransaction>> {};
 struct btck_TransactionOutput : Handle<btck_TransactionOutput, CTxOut> {};
 struct btck_ScriptPubkey : Handle<btck_ScriptPubkey, CScript> {};
 struct btck_LoggingConnection : Handle<btck_LoggingConnection, LoggingConnection> {};
+struct btck_ContextOptions : Handle<btck_ContextOptions, ContextOptions> {};
+struct btck_Context : Handle<btck_Context, std::shared_ptr<const Context>> {};
 
 btck_Transaction* btck_transaction_create(const void* raw_transaction, size_t raw_transaction_len)
 {
@@ -408,3 +442,35 @@ void btck_logging_connection_destroy(btck_LoggingConnection* connection)
 {
     delete connection;
 }
+
+btck_ContextOptions* btck_context_options_create()
+{
+    return btck_ContextOptions::create();
+}
+
+void btck_context_options_destroy(btck_ContextOptions* options)
+{
+    delete options;
+}
+
+btck_Context* btck_context_create(const btck_ContextOptions* options)
+{
+    bool sane{true};
+    const ContextOptions* opts = options ? &btck_ContextOptions::get(options) : nullptr;
+    auto context{std::make_shared<const Context>(opts, sane)};
+    if (!sane) {
+        LogError("Kernel context sanity check failed.");
+        return nullptr;
+    }
+    return btck_Context::create(context);
+}
+
+btck_Context* btck_context_copy(const btck_Context* context)
+{
+    return btck_Context::copy(context);
+}
+
+void btck_context_destroy(btck_Context* context)
+{
+    delete context;
+}
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index 1bdf56d77b3..4dca2e85396 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -57,6 +57,9 @@ extern "C" {
  * otherwise "context-free" operations. This means that the user is not
  * required to initialize their own context before using the library.
  *
+ * The user should create their own context for passing it to state-rich validation
+ * functions and holding callbacks for kernel events.
+ *
  * @section error Error handling
  *
  * Functions communicate an error through their return types, usually returning
@@ -112,6 +115,29 @@ typedef struct btck_TransactionOutput btck_TransactionOutput;
  */
 typedef struct btck_LoggingConnection btck_LoggingConnection;
 
+/**
+ * Opaque data structure for holding options for creating a new kernel context.
+ *
+ * Once a kernel context has been created from these options, they may be
+ * destroyed. The options hold the notification callbacks as well as the
+ * selected chain type until they are passed to the context. If no options are
+ * configured, the context will be instantiated with no callbacks and for
+ * mainnet. Their content and scope can be expanded over time.
+ */
+typedef struct btck_ContextOptions btck_ContextOptions;
+
+/**
+ * Opaque data structure for holding a kernel context.
+ *
+ * The kernel context is used to initialize internal state and hold the chain
+ * parameters and callbacks for handling error and validation events. Once
+ * other validation objects are instantiated from it, the context is kept in
+ * memory for the duration of their lifetimes.
+ *
+ * A constructed context can be safely used from multiple threads.
+ */
+typedef struct btck_Context btck_Context;
+
 /** Callback function types */
 
 /**
@@ -470,6 +496,53 @@ BITCOINKERNEL_API void btck_logging_connection_destroy(btck_LoggingConnection* l
 
 ///@}
 
+/** @name ContextOptions
+ * Functions for working with context options.
+ */
+///@{
+
+/**
+ * Creates an empty context options.
+ */
+BITCOINKERNEL_API btck_ContextOptions* BITCOINKERNEL_WARN_UNUSED_RESULT btck_context_options_create();
+
+/**
+ * Destroy the context options.
+ */
+BITCOINKERNEL_API void btck_context_options_destroy(btck_ContextOptions* context_options);
+
+///@}
+
+/** @name Context
+ * Functions for working with contexts.
+ */
+///@{
+
+/**
+ * @brief Create a new kernel context. If the options have not been previously
+ * set, their corresponding fields will be initialized to default values; the
+ * context will assume mainnet chain parameters and won't attempt to call the
+ * kernel notification callbacks.
+ *
+ * @param[in] context_options Nullable, created by @ref btck_context_options_create.
+ * @return                    The allocated kernel context, or null on error.
+ */
+BITCOINKERNEL_API btck_Context* BITCOINKERNEL_WARN_UNUSED_RESULT btck_context_create(
+    const btck_ContextOptions* context_options);
+
+/**
+ * Copy the context.
+ */
+BITCOINKERNEL_API btck_Context* BITCOINKERNEL_WARN_UNUSED_RESULT btck_context_copy(
+    const btck_Context* context) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Destroy the context.
+ */
+BITCOINKERNEL_API void btck_context_destroy(btck_Context* context);
+
+///@}
+
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index f3a235f2ba0..a6f8ab9886f 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -318,8 +318,8 @@ protected:
 public:
     explicit UniqueHandle(CType* ptr) : m_ptr{check(ptr)} {}
 
-    CType* get() { return m_ptr; }
-    const CType* get() const { return m_ptr; }
+    CType* get() { return m_ptr.get(); }
+    const CType* get() const { return m_ptr.get(); }
 };
 
 class Transaction;
@@ -505,7 +505,7 @@ concept Log = requires(T a, std::string_view message) {
 };
 
 template <Log T>
-class Logger : public UniqueHandle<btck_LoggingConnection, btck_logging_connection_destroy>
+class Logger : UniqueHandle<btck_LoggingConnection, btck_logging_connection_destroy>
 {
 public:
     Logger(std::unique_ptr<T> log, const btck_LoggingOptions& logging_options)
@@ -518,6 +518,24 @@ public:
     }
 };
 
+class ContextOptions : UniqueHandle<btck_ContextOptions, btck_context_options_destroy>
+{
+public:
+    ContextOptions() : UniqueHandle{btck_context_options_create()} {}
+
+    friend class Context;
+};
+
+class Context : public Handle<btck_Context, btck_context_copy, btck_context_destroy>
+{
+public:
+    Context(ContextOptions& opts)
+        : Handle{btck_context_create(opts.get())} {}
+
+    Context()
+        : Handle{btck_context_create(ContextOptions{}.get())} {}
+};
+
 } // namespace btck
 
 #endif // BITCOIN_KERNEL_BITCOINKERNEL_WRAPPER_H
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index 5c935db088b..02394c157e1 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -384,3 +384,17 @@ BOOST_AUTO_TEST_CASE(logging_tests)
     }
     Logger logger{std::make_unique<TestLog>(TestLog{}), logging_options};
 }
+
+BOOST_AUTO_TEST_CASE(btck_context_tests)
+{
+    { // test default context
+        Context context{};
+        Context context2{};
+        CheckHandle(context, context2);
+    }
+
+    { // test with context options
+        ContextOptions options{};
+        Context context{options};
+    }
+}

From 86cd091d7428d907fbbc0da289cbd5384e110493 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Mon, 3 Jun 2024 14:44:55 +0200
Subject: [PATCH 04/24] kernel: Add chain params context option to C header

As a first option, add the chainparams. For now these can only be
instantiated with default values. In future they may be expanded to take
their own options for regtest and signet configurations.

This commit also introduces a unique pattern for setting the option
values when calling the `*_set(...)` function.
---
 src/kernel/bitcoinkernel.cpp       | 63 +++++++++++++++++++++++++++++-
 src/kernel/bitcoinkernel.h         | 55 ++++++++++++++++++++++++++
 src/kernel/bitcoinkernel_wrapper.h | 22 +++++++++++
 src/test/kernel/test_kernel.cpp    | 11 +++++-
 4 files changed, 148 insertions(+), 3 deletions(-)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index 180cf1e823e..2d70474eb4b 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -18,6 +18,7 @@
 #include <script/script.h>
 #include <serialize.h>
 #include <streams.h>
+#include <sync.h>
 #include <tinyformat.h>
 #include <util/result.h>
 #include <util/signalinterrupt.h>
@@ -108,6 +109,11 @@ struct Handle {
         return *reinterpret_cast<const CPP*>(ptr);
     }
 
+    static CPP& get(C* ptr)
+    {
+        return *reinterpret_cast<CPP*>(ptr);
+    }
+
     static void operator delete(void* ptr)
     {
         delete reinterpret_cast<CPP*>(ptr);
@@ -228,6 +234,8 @@ struct LoggingConnection {
 };
 
 struct ContextOptions {
+    mutable Mutex m_mutex;
+    std::unique_ptr<const CChainParams> m_chainparams GUARDED_BY(m_mutex);
 };
 
 class Context
@@ -244,9 +252,19 @@ public:
     Context(const ContextOptions* options, bool& sane)
         : m_context{std::make_unique<kernel::Context>()},
           m_notifications{std::make_unique<kernel::Notifications>()},
-          m_interrupt{std::make_unique<util::SignalInterrupt>()},
-          m_chainparams{CChainParams::Main()}
+          m_interrupt{std::make_unique<util::SignalInterrupt>()}
     {
+        if (options) {
+            LOCK(options->m_mutex);
+            if (options->m_chainparams) {
+                m_chainparams = std::make_unique<const CChainParams>(*options->m_chainparams);
+            }
+        }
+
+        if (!m_chainparams) {
+            m_chainparams = CChainParams::Main();
+        }
+
         if (!kernel::SanityChecks(*m_context)) {
             sane = false;
         }
@@ -261,6 +279,7 @@ struct btck_ScriptPubkey : Handle<btck_ScriptPubkey, CScript> {};
 struct btck_LoggingConnection : Handle<btck_LoggingConnection, LoggingConnection> {};
 struct btck_ContextOptions : Handle<btck_ContextOptions, ContextOptions> {};
 struct btck_Context : Handle<btck_Context, std::shared_ptr<const Context>> {};
+struct btck_ChainParameters : Handle<btck_ChainParameters, std::unique_ptr<const CChainParams>> {};
 
 btck_Transaction* btck_transaction_create(const void* raw_transaction, size_t raw_transaction_len)
 {
@@ -443,11 +462,51 @@ void btck_logging_connection_destroy(btck_LoggingConnection* connection)
     delete connection;
 }
 
+btck_ChainParameters* btck_chain_parameters_create(const btck_ChainType chain_type)
+{
+    switch (chain_type) {
+    case btck_ChainType_MAINNET: {
+        return btck_ChainParameters::create(CChainParams::Main());
+    }
+    case btck_ChainType_TESTNET: {
+        return btck_ChainParameters::create(CChainParams::TestNet());
+    }
+    case btck_ChainType_TESTNET_4: {
+        return btck_ChainParameters::create(CChainParams::TestNet4());
+    }
+    case btck_ChainType_SIGNET: {
+        return btck_ChainParameters::create(CChainParams::SigNet({}));
+    }
+    case btck_ChainType_REGTEST: {
+        return btck_ChainParameters::create(CChainParams::RegTest({}));
+    }
+    }
+    assert(false);
+}
+
+btck_ChainParameters* btck_chain_parameters_copy(const btck_ChainParameters* chain_parameters)
+{
+    const auto& original = btck_ChainParameters::get(chain_parameters);
+    return btck_ChainParameters::create(std::make_unique<const CChainParams>(*original));
+}
+
+void btck_chain_parameters_destroy(btck_ChainParameters* chain_parameters)
+{
+    delete chain_parameters;
+}
+
 btck_ContextOptions* btck_context_options_create()
 {
     return btck_ContextOptions::create();
 }
 
+void btck_context_options_set_chainparams(btck_ContextOptions* options, const btck_ChainParameters* chain_parameters)
+{
+    // Copy the chainparams, so the caller can free it again
+    LOCK(btck_ContextOptions::get(options).m_mutex);
+    btck_ContextOptions::get(options).m_chainparams = std::make_unique<const CChainParams>(*btck_ChainParameters::get(chain_parameters));
+}
+
 void btck_context_options_destroy(btck_ContextOptions* options)
 {
     delete options;
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index 4dca2e85396..b0a0b6af2a4 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -115,6 +115,15 @@ typedef struct btck_TransactionOutput btck_TransactionOutput;
  */
 typedef struct btck_LoggingConnection btck_LoggingConnection;
 
+/**
+ * Opaque data structure for holding the chain parameters.
+ *
+ * These are eventually placed into a kernel context through the kernel context
+ * options. The parameters describe the properties of a chain, and may be
+ * instantiated for either mainnet, testnet, signet, or regtest.
+ */
+typedef struct btck_ChainParameters btck_ChainParameters;
+
 /**
  * Opaque data structure for holding options for creating a new kernel context.
  *
@@ -216,6 +225,13 @@ typedef uint32_t btck_ScriptVerificationFlags;
                                                                          btck_ScriptVerificationFlags_WITNESS |             \
                                                                          btck_ScriptVerificationFlags_TAPROOT))
 
+typedef uint8_t btck_ChainType;
+#define btck_ChainType_MAINNET ((btck_ChainType)(0))
+#define btck_ChainType_TESTNET ((btck_ChainType)(1))
+#define btck_ChainType_TESTNET_4 ((btck_ChainType)(2))
+#define btck_ChainType_SIGNET ((btck_ChainType)(3))
+#define btck_ChainType_REGTEST ((btck_ChainType)(4))
+
 /**
  * Function signature for serializing data.
  */
@@ -496,6 +512,34 @@ BITCOINKERNEL_API void btck_logging_connection_destroy(btck_LoggingConnection* l
 
 ///@}
 
+/** @name ChainParameters
+ * Functions for working with chain parameters.
+ */
+///@{
+
+/**
+ * @brief Creates a chain parameters struct with default parameters based on the
+ * passed in chain type.
+ *
+ * @param[in] chain_type Controls the chain parameters type created.
+ * @return               An allocated chain parameters opaque struct.
+ */
+BITCOINKERNEL_API btck_ChainParameters* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chain_parameters_create(
+    const btck_ChainType chain_type);
+
+/**
+ * Copy the chain parameters.
+ */
+BITCOINKERNEL_API btck_ChainParameters* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chain_parameters_copy(
+    const btck_ChainParameters* chain_parameters) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Destroy the chain parameters.
+ */
+BITCOINKERNEL_API void btck_chain_parameters_destroy(btck_ChainParameters* chain_parameters);
+
+///@}
+
 /** @name ContextOptions
  * Functions for working with context options.
  */
@@ -506,6 +550,17 @@ BITCOINKERNEL_API void btck_logging_connection_destroy(btck_LoggingConnection* l
  */
 BITCOINKERNEL_API btck_ContextOptions* BITCOINKERNEL_WARN_UNUSED_RESULT btck_context_options_create();
 
+/**
+ * @brief Sets the chain params for the context options. The context created
+ * with the options will be configured for these chain parameters.
+ *
+ * @param[in] context_options  Non-null, previously created by @ref btck_context_options_create.
+ * @param[in] chain_parameters Is set to the context options.
+ */
+BITCOINKERNEL_API void btck_context_options_set_chainparams(
+    btck_ContextOptions* context_options,
+    const btck_ChainParameters* chain_parameters) BITCOINKERNEL_ARG_NONNULL(1, 2);
+
 /**
  * Destroy the context options.
  */
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index a6f8ab9886f..14a65e4fa22 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -41,6 +41,14 @@ enum class LogLevel : btck_LogLevel {
     INFO_LEVEL = btck_LogLevel_INFO
 };
 
+enum class ChainType : btck_ChainType {
+    MAINNET = btck_ChainType_MAINNET,
+    TESTNET = btck_ChainType_TESTNET,
+    TESTNET_4 = btck_ChainType_TESTNET_4,
+    SIGNET = btck_ChainType_SIGNET,
+    REGTEST = btck_ChainType_REGTEST
+};
+
 enum class ScriptVerifyStatus : btck_ScriptVerifyStatus {
     OK = btck_ScriptVerifyStatus_SCRIPT_VERIFY_OK,
     ERROR_INVALID_FLAGS_COMBINATION = btck_ScriptVerifyStatus_ERROR_INVALID_FLAGS_COMBINATION,
@@ -518,11 +526,25 @@ public:
     }
 };
 
+class ChainParams : public Handle<btck_ChainParameters, btck_chain_parameters_copy, btck_chain_parameters_destroy>
+{
+public:
+    ChainParams(ChainType chain_type)
+        : Handle{btck_chain_parameters_create(static_cast<btck_ChainType>(chain_type))} {}
+
+    friend class ContextOptions;
+};
+
 class ContextOptions : UniqueHandle<btck_ContextOptions, btck_context_options_destroy>
 {
 public:
     ContextOptions() : UniqueHandle{btck_context_options_create()} {}
 
+    void SetChainParams(ChainParams& chain_params)
+    {
+        btck_context_options_set_chainparams(get(), chain_params.get());
+    }
+
     friend class Context;
 };
 
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index 02394c157e1..c2e52c751aa 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -393,8 +393,17 @@ BOOST_AUTO_TEST_CASE(btck_context_tests)
         CheckHandle(context, context2);
     }
 
-    { // test with context options
+    { // test with context options, but not options set
         ContextOptions options{};
         Context context{options};
     }
+
+    { // test with context options
+        ContextOptions options{};
+        ChainParams params{ChainType::MAINNET};
+        ChainParams regtest_params{ChainType::REGTEST};
+        CheckHandle(params, regtest_params);
+        options.SetChainParams(params);
+        Context context{options};
+    }
 }

From 96651a3f8636bae301b639d781fba3db31c597c9 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Mon, 3 Jun 2024 14:51:29 +0200
Subject: [PATCH 05/24] kernel: Add notifications context option to C header

The notifications are used for notifying on connected blocks and on
warning and fatal error conditions.

The user of the C header may define callbacks that gets passed to the
internal notification object in the
`kernel_NotificationInterfaceCallbacks` struct.

Each of the callbacks take a `user_data` argument that gets populated
from the `user_data` value in the struct. It can be used to recreate the
structure containing the callbacks on the user's side, or to give the
callbacks additional contextual information.
---
 src/kernel/bitcoinkernel.cpp       | 103 ++++++++++++++++++++++++++++-
 src/kernel/bitcoinkernel.h         |  75 ++++++++++++++++++++-
 src/kernel/bitcoinkernel_wrapper.h |  62 +++++++++++++++++
 src/test/kernel/test_kernel.cpp    |  30 +++++++++
 4 files changed, 267 insertions(+), 3 deletions(-)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index 2d70474eb4b..1a136496b3d 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -12,6 +12,7 @@
 #include <kernel/context.h>
 #include <kernel/cs_main.h>
 #include <kernel/notifications_interface.h>
+#include <kernel/warning.h>
 #include <logging.h>
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
@@ -23,6 +24,7 @@
 #include <util/result.h>
 #include <util/signalinterrupt.h>
 #include <util/translation.h>
+#include <validation.h>
 
 #include <cassert>
 #include <cstddef>
@@ -36,6 +38,8 @@
 #include <utility>
 #include <vector>
 
+class CBlockIndex;
+
 // Define G_TRANSLATION_FUN symbol in libbitcoinkernel library so users of the
 // library aren't required to export this symbol
 extern const std::function<std::string(const char*)> G_TRANSLATION_FUN{nullptr};
@@ -120,6 +124,12 @@ struct Handle {
     }
 };
 
+} // namespace
+
+struct btck_BlockTreeEntry: Handle<btck_BlockTreeEntry, CBlockIndex> {};
+
+namespace {
+
 BCLog::Level get_bclog_level(btck_LogLevel level)
 {
     switch (level) {
@@ -176,6 +186,30 @@ BCLog::LogFlags get_bclog_flag(btck_LogCategory category)
     assert(false);
 }
 
+btck_SynchronizationState cast_state(SynchronizationState state)
+{
+    switch (state) {
+    case SynchronizationState::INIT_REINDEX:
+        return btck_SynchronizationState_INIT_REINDEX;
+    case SynchronizationState::INIT_DOWNLOAD:
+        return btck_SynchronizationState_INIT_DOWNLOAD;
+    case SynchronizationState::POST_INIT:
+        return btck_SynchronizationState_POST_INIT;
+    } // no default case, so the compiler can warn about missing cases
+    assert(false);
+}
+
+btck_Warning cast_btck_warning(kernel::Warning warning)
+{
+    switch (warning) {
+    case kernel::Warning::UNKNOWN_NEW_RULES_ACTIVATED:
+        return btck_Warning_UNKNOWN_NEW_RULES_ACTIVATED;
+    case kernel::Warning::LARGE_WORK_INVALID_CHAIN:
+        return btck_Warning_LARGE_WORK_INVALID_CHAIN;
+    } // no default case, so the compiler can warn about missing cases
+    assert(false);
+}
+
 struct LoggingConnection {
     std::unique_ptr<std::list<std::function<void(const std::string&)>>::iterator> m_connection;
     void* m_user_data;
@@ -233,9 +267,61 @@ struct LoggingConnection {
     }
 };
 
+class KernelNotifications : public kernel::Notifications
+{
+private:
+    btck_NotificationInterfaceCallbacks m_cbs;
+
+public:
+    KernelNotifications(btck_NotificationInterfaceCallbacks cbs)
+        : m_cbs{cbs}
+    {
+    }
+
+    ~KernelNotifications()
+    {
+        if (m_cbs.user_data && m_cbs.user_data_destroy) {
+            m_cbs.user_data_destroy(m_cbs.user_data);
+        }
+        m_cbs.user_data_destroy = nullptr;
+        m_cbs.user_data = nullptr;
+    }
+
+    kernel::InterruptResult blockTip(SynchronizationState state, const CBlockIndex& index, double verification_progress) override
+    {
+        if (m_cbs.block_tip) m_cbs.block_tip(m_cbs.user_data, cast_state(state), btck_BlockTreeEntry::ref(&index), verification_progress);
+        return {};
+    }
+    void headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) override
+    {
+        if (m_cbs.header_tip) m_cbs.header_tip(m_cbs.user_data, cast_state(state), height, timestamp, presync ? 1 : 0);
+    }
+    void progress(const bilingual_str& title, int progress_percent, bool resume_possible) override
+    {
+        if (m_cbs.progress) m_cbs.progress(m_cbs.user_data, title.original.c_str(), title.original.length(), progress_percent, resume_possible ? 1 : 0);
+    }
+    void warningSet(kernel::Warning id, const bilingual_str& message) override
+    {
+        if (m_cbs.warning_set) m_cbs.warning_set(m_cbs.user_data, cast_btck_warning(id), message.original.c_str(), message.original.length());
+    }
+    void warningUnset(kernel::Warning id) override
+    {
+        if (m_cbs.warning_unset) m_cbs.warning_unset(m_cbs.user_data, cast_btck_warning(id));
+    }
+    void flushError(const bilingual_str& message) override
+    {
+        if (m_cbs.flush_error) m_cbs.flush_error(m_cbs.user_data, message.original.c_str(), message.original.length());
+    }
+    void fatalError(const bilingual_str& message) override
+    {
+        if (m_cbs.fatal_error) m_cbs.fatal_error(m_cbs.user_data, message.original.c_str(), message.original.length());
+    }
+};
+
 struct ContextOptions {
     mutable Mutex m_mutex;
     std::unique_ptr<const CChainParams> m_chainparams GUARDED_BY(m_mutex);
+    std::shared_ptr<KernelNotifications> m_notifications GUARDED_BY(m_mutex);
 };
 
 class Context
@@ -243,7 +329,7 @@ class Context
 public:
     std::unique_ptr<kernel::Context> m_context;
 
-    std::unique_ptr<kernel::Notifications> m_notifications;
+    std::shared_ptr<KernelNotifications> m_notifications;
 
     std::unique_ptr<util::SignalInterrupt> m_interrupt;
 
@@ -251,7 +337,6 @@ public:
 
     Context(const ContextOptions* options, bool& sane)
         : m_context{std::make_unique<kernel::Context>()},
-          m_notifications{std::make_unique<kernel::Notifications>()},
           m_interrupt{std::make_unique<util::SignalInterrupt>()}
     {
         if (options) {
@@ -259,11 +344,18 @@ public:
             if (options->m_chainparams) {
                 m_chainparams = std::make_unique<const CChainParams>(*options->m_chainparams);
             }
+            if (options->m_notifications) {
+                m_notifications = options->m_notifications;
+            }
         }
 
         if (!m_chainparams) {
             m_chainparams = CChainParams::Main();
         }
+        if (!m_notifications) {
+            m_notifications = std::make_shared<KernelNotifications>(btck_NotificationInterfaceCallbacks{
+                nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr});
+        }
 
         if (!kernel::SanityChecks(*m_context)) {
             sane = false;
@@ -507,6 +599,13 @@ void btck_context_options_set_chainparams(btck_ContextOptions* options, const bt
     btck_ContextOptions::get(options).m_chainparams = std::make_unique<const CChainParams>(*btck_ChainParameters::get(chain_parameters));
 }
 
+void btck_context_options_set_notifications(btck_ContextOptions* options, btck_NotificationInterfaceCallbacks notifications)
+{
+    // The KernelNotifications are copy-initialized, so the caller can free them again.
+    LOCK(btck_ContextOptions::get(options).m_mutex);
+    btck_ContextOptions::get(options).m_notifications = std::make_shared<KernelNotifications>(notifications);
+}
+
 void btck_context_options_destroy(btck_ContextOptions* options)
 {
     delete options;
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index b0a0b6af2a4..4018710078a 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -67,6 +67,11 @@ extern "C" {
  * functions, e.g. for scripts, may communicate more detailed error information
  * through status code out parameters.
  *
+ * The kernel notifications issue callbacks for errors. These are usually
+ * indicative of a system error. If such an error is issued, it is recommended
+ * to halt and tear down the existing kernel objects. Remediating the error may
+ * require system intervention by the user.
+ *
  * @section pointer Pointer and argument conventions
  *
  * The user is responsible for de-allocating the memory owned by pointers
@@ -147,6 +152,30 @@ typedef struct btck_ContextOptions btck_ContextOptions;
  */
 typedef struct btck_Context btck_Context;
 
+/**
+ * Opaque data structure for holding a block tree entry.
+ *
+ * This is a pointer to an element in the block index currently in memory of
+ * the chainstate manager. It is valid for the lifetime of the chainstate
+ * manager it was retrieved from. The entry is part of a tree-like structure
+ * that is maintained internally. Every entry, besides the genesis, points to a
+ * single parent. Multiple entries may share a parent, thus forming a tree.
+ * Each entry corresponds to a single block and may be used to retrieve its
+ * data and validation status.
+ */
+typedef struct btck_BlockTreeEntry btck_BlockTreeEntry;
+
+/** Current sync state passed to tip changed callbacks. */
+typedef uint8_t btck_SynchronizationState;
+#define btck_SynchronizationState_INIT_REINDEX ((btck_SynchronizationState)(0))
+#define btck_SynchronizationState_INIT_DOWNLOAD ((btck_SynchronizationState)(1))
+#define btck_SynchronizationState_POST_INIT ((btck_SynchronizationState)(2))
+
+/** Possible warning types issued by validation. */
+typedef uint8_t btck_Warning;
+#define btck_Warning_UNKNOWN_NEW_RULES_ACTIVATED ((btck_Warning)(0))
+#define btck_Warning_LARGE_WORK_INVALID_CHAIN ((btck_Warning)(1))
+
 /** Callback function types */
 
 /**
@@ -160,6 +189,39 @@ typedef void (*btck_LogCallback)(void* user_data, const char* message, size_t me
  */
 typedef void (*btck_DestroyCallback)(void* user_data);
 
+/**
+ * Function signatures for the kernel notifications.
+ */
+typedef void (*btck_NotifyBlockTip)(void* user_data, btck_SynchronizationState state, const btck_BlockTreeEntry* entry, double verification_progress);
+typedef void (*btck_NotifyHeaderTip)(void* user_data, btck_SynchronizationState state, int64_t height, int64_t timestamp, int presync);
+typedef void (*btck_NotifyProgress)(void* user_data, const char* title, size_t title_len, int progress_percent, int resume_possible);
+typedef void (*btck_NotifyWarningSet)(void* user_data, btck_Warning warning, const char* message, size_t message_len);
+typedef void (*btck_NotifyWarningUnset)(void* user_data, btck_Warning warning);
+typedef void (*btck_NotifyFlushError)(void* user_data, const char* message, size_t message_len);
+typedef void (*btck_NotifyFatalError)(void* user_data, const char* message, size_t message_len);
+
+/**
+ * A struct for holding the kernel notification callbacks. The user data
+ * pointer may be used to point to user-defined structures to make processing
+ * the notifications easier. Note that this makes it the user's responsibility
+ * to ensure that the user_data outlives the kernel objects. Notifications can
+ * occur even as kernel objects are deleted, so care has to be taken to ensure
+ * safe unwinding.
+ */
+typedef struct {
+    void* user_data;                        //!< Holds a user-defined opaque structure that is passed to the notification callbacks.
+                                            //!< If user_data_destroy is also defined ownership of the user_data is passed to the
+                                            //!< created context options and subsequently context.
+    btck_DestroyCallback user_data_destroy; //!< Frees the provided user data structure.
+    btck_NotifyBlockTip block_tip;          //!< The chain's tip was updated to the provided block entry.
+    btck_NotifyHeaderTip header_tip;        //!< A new best block header was added.
+    btck_NotifyProgress progress;           //!< Reports on current block synchronization progress.
+    btck_NotifyWarningSet warning_set;      //!< A warning issued by the kernel library during validation.
+    btck_NotifyWarningUnset warning_unset;  //!< A previous condition leading to the issuance of a warning is no longer given.
+    btck_NotifyFlushError flush_error;      //!< An error encountered when flushing data to disk.
+    btck_NotifyFatalError fatal_error;      //!< A un-recoverable system error encountered by the library.
+} btck_NotificationInterfaceCallbacks;
+
 /**
  * A collection of logging categories that may be encountered by kernel code.
  */
@@ -561,6 +623,17 @@ BITCOINKERNEL_API void btck_context_options_set_chainparams(
     btck_ContextOptions* context_options,
     const btck_ChainParameters* chain_parameters) BITCOINKERNEL_ARG_NONNULL(1, 2);
 
+/**
+ * @brief Set the kernel notifications for the context options. The context
+ * created with the options will be configured with these notifications.
+ *
+ * @param[in] context_options Non-null, previously created by @ref btck_context_options_create.
+ * @param[in] notifications   Is set to the context options.
+ */
+BITCOINKERNEL_API void btck_context_options_set_notifications(
+    btck_ContextOptions* context_options,
+    btck_NotificationInterfaceCallbacks notifications) BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * Destroy the context options.
  */
@@ -580,7 +653,7 @@ BITCOINKERNEL_API void btck_context_options_destroy(btck_ContextOptions* context
  * kernel notification callbacks.
  *
  * @param[in] context_options Nullable, created by @ref btck_context_options_create.
- * @return                    The allocated kernel context, or null on error.
+ * @return                    The allocated context, or null on error.
  */
 BITCOINKERNEL_API btck_Context* BITCOINKERNEL_WARN_UNUSED_RESULT btck_context_create(
     const btck_ContextOptions* context_options);
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index 14a65e4fa22..a2c2dcc5fce 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -49,6 +49,17 @@ enum class ChainType : btck_ChainType {
     REGTEST = btck_ChainType_REGTEST
 };
 
+enum class SynchronizationState : btck_SynchronizationState {
+    INIT_REINDEX = btck_SynchronizationState_INIT_REINDEX,
+    INIT_DOWNLOAD = btck_SynchronizationState_INIT_DOWNLOAD,
+    POST_INIT = btck_SynchronizationState_POST_INIT
+};
+
+enum class Warning : btck_Warning {
+    UNKNOWN_NEW_RULES_ACTIVATED = btck_Warning_UNKNOWN_NEW_RULES_ACTIVATED,
+    LARGE_WORK_INVALID_CHAIN = btck_Warning_LARGE_WORK_INVALID_CHAIN
+};
+
 enum class ScriptVerifyStatus : btck_ScriptVerifyStatus {
     OK = btck_ScriptVerifyStatus_SCRIPT_VERIFY_OK,
     ERROR_INVALID_FLAGS_COMBINATION = btck_ScriptVerifyStatus_ERROR_INVALID_FLAGS_COMBINATION,
@@ -526,6 +537,36 @@ public:
     }
 };
 
+class BlockTreeEntry : View<btck_BlockTreeEntry>
+{
+public:
+    BlockTreeEntry(const btck_BlockTreeEntry* entry)
+        : View{entry}
+    {
+    }
+};
+
+template <typename T>
+class KernelNotifications
+{
+public:
+    virtual ~KernelNotifications() = default;
+
+    virtual void BlockTipHandler(SynchronizationState state, BlockTreeEntry entry, double verification_progress) {}
+
+    virtual void HeaderTipHandler(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) {}
+
+    virtual void ProgressHandler(std::string_view title, int progress_percent, bool resume_possible) {}
+
+    virtual void WarningSetHandler(Warning warning, std::string_view message) {}
+
+    virtual void WarningUnsetHandler(Warning warning) {}
+
+    virtual void FlushErrorHandler(std::string_view error) {}
+
+    virtual void FatalErrorHandler(std::string_view error) {}
+};
+
 class ChainParams : public Handle<btck_ChainParameters, btck_chain_parameters_copy, btck_chain_parameters_destroy>
 {
 public:
@@ -545,6 +586,27 @@ public:
         btck_context_options_set_chainparams(get(), chain_params.get());
     }
 
+    template <typename T>
+    void SetNotifications(std::shared_ptr<T> notifications)
+    {
+        static_assert(std::is_base_of_v<KernelNotifications<T>, T>);
+        auto heap_notifications = std::make_unique<std::shared_ptr<T>>(std::move(notifications));
+        using user_type = std::shared_ptr<T>*;
+        btck_context_options_set_notifications(
+            get(),
+            btck_NotificationInterfaceCallbacks{
+                .user_data = heap_notifications.release(),
+                .user_data_destroy = +[](void* user_data) { delete static_cast<user_type>(user_data); },
+                .block_tip = +[](void* user_data, btck_SynchronizationState state, const btck_BlockTreeEntry* entry, double verification_progress) { (*static_cast<user_type>(user_data))->BlockTipHandler(static_cast<SynchronizationState>(state), BlockTreeEntry{entry}, verification_progress); },
+                .header_tip = +[](void* user_data, btck_SynchronizationState state, int64_t height, int64_t timestamp, int presync) { (*static_cast<user_type>(user_data))->HeaderTipHandler(static_cast<SynchronizationState>(state), height, timestamp, presync == 1); },
+                .progress = +[](void* user_data, const char* title, size_t title_len, int progress_percent, int resume_possible) { (*static_cast<user_type>(user_data))->ProgressHandler({title, title_len}, progress_percent, resume_possible == 1); },
+                .warning_set = +[](void* user_data, btck_Warning warning, const char* message, size_t message_len) { (*static_cast<user_type>(user_data))->WarningSetHandler(static_cast<Warning>(warning), {message, message_len}); },
+                .warning_unset = +[](void* user_data, btck_Warning warning) { (*static_cast<user_type>(user_data))->WarningUnsetHandler(static_cast<Warning>(warning)); },
+                .flush_error = +[](void* user_data, const char* error, size_t error_len) { (*static_cast<user_type>(user_data))->FlushErrorHandler({error, error_len}); },
+                .fatal_error = +[](void* user_data, const char* error, size_t error_len) { (*static_cast<user_type>(user_data))->FatalErrorHandler({error, error_len}); },
+            });
+    }
+
     friend class Context;
 };
 
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index c2e52c751aa..6258bf69a95 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -60,6 +60,35 @@ public:
     }
 };
 
+class TestKernelNotifications : public KernelNotifications<TestKernelNotifications>
+{
+public:
+    void HeaderTipHandler(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) override
+    {
+        BOOST_CHECK_GT(timestamp, 0);
+    }
+
+    void WarningSetHandler(Warning warning, std::string_view message) override
+    {
+        std::cout << "Kernel warning is set: " << message << std::endl;
+    }
+
+    void WarningUnsetHandler(Warning warning) override
+    {
+        std::cout << "Kernel warning was unset." << std::endl;
+    }
+
+    void FlushErrorHandler(std::string_view error) override
+    {
+        std::cout << error << std::endl;
+    }
+
+    void FatalErrorHandler(std::string_view error) override
+    {
+        std::cout << error << std::endl;
+    }
+};
+
 void run_verify_test(
     const ScriptPubkey& spent_script_pubkey,
     const Transaction& spending_tx,
@@ -404,6 +433,7 @@ BOOST_AUTO_TEST_CASE(btck_context_tests)
         ChainParams regtest_params{ChainType::REGTEST};
         CheckHandle(params, regtest_params);
         options.SetChainParams(params);
+        options.SetNotifications(std::make_shared<TestKernelNotifications>());
         Context context{options};
     }
 }

From dee984def69b972db386ff6806f09acbb502d9bd Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Tue, 28 May 2024 20:58:48 +0200
Subject: [PATCH 06/24] kernel: Add chainstate manager object to C header

This is the main driver class for anything validation related, so expose
it here.

Creating the chainstate manager options will currently also trigger the
creation of their respectively configured directories.

The chainstate manager and block manager options are consolidated into a
single object. The kernel might eventually introduce a separate block
manager object for the purposes of being a light-weight block store
reader.

The chainstate manager will associate with the context with which it was
created for the duration of its lifetime. It is only valid if that
context remains in memory too.

The tests now also create dedicated temporary directories. This is
similar to the behaviour in the existing unit test framework.

Co-authored-by: stickies-v <stickies-v@protonmail.com>
---
 src/kernel/bitcoinkernel.cpp       | 87 ++++++++++++++++++++++++++++++
 src/kernel/bitcoinkernel.h         | 72 +++++++++++++++++++++++++
 src/kernel/bitcoinkernel_wrapper.h | 23 ++++++++
 src/test/kernel/test_kernel.cpp    | 77 ++++++++++++++++++++++++++
 test/lint/test_runner/src/main.rs  |  1 +
 5 files changed, 260 insertions(+)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index 1a136496b3d..88fc9fbab04 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -7,6 +7,7 @@
 #include <kernel/bitcoinkernel.h>
 
 #include <consensus/amount.h>
+#include <kernel/caches.h>
 #include <kernel/chainparams.h>
 #include <kernel/checks.h>
 #include <kernel/context.h>
@@ -14,6 +15,7 @@
 #include <kernel/notifications_interface.h>
 #include <kernel/warning.h>
 #include <logging.h>
+#include <node/blockstorage.h>
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
 #include <script/script.h>
@@ -21,6 +23,7 @@
 #include <streams.h>
 #include <sync.h>
 #include <tinyformat.h>
+#include <util/fs.h>
 #include <util/result.h>
 #include <util/signalinterrupt.h>
 #include <util/translation.h>
@@ -363,6 +366,39 @@ public:
     }
 };
 
+//! Helper struct to wrap the ChainstateManager-related Options
+struct ChainstateManagerOptions {
+    mutable Mutex m_mutex;
+    ChainstateManager::Options m_chainman_options GUARDED_BY(m_mutex);
+    node::BlockManager::Options m_blockman_options GUARDED_BY(m_mutex);
+    std::shared_ptr<const Context> m_context;
+
+    ChainstateManagerOptions(const std::shared_ptr<const Context>& context, const fs::path& data_dir, const fs::path& blocks_dir)
+        : m_chainman_options{ChainstateManager::Options{
+              .chainparams = *context->m_chainparams,
+              .datadir = data_dir,
+              .notifications = *context->m_notifications}},
+          m_blockman_options{node::BlockManager::Options{
+              .chainparams = *context->m_chainparams,
+              .blocks_dir = blocks_dir,
+              .notifications = *context->m_notifications,
+              .block_tree_db_params = DBParams{
+                  .path = data_dir / "blocks" / "index",
+                  .cache_bytes = kernel::CacheSizes{DEFAULT_KERNEL_CACHE}.block_tree_db,
+              }}},
+          m_context{context}
+    {
+    }
+};
+
+struct ChainMan {
+    std::unique_ptr<ChainstateManager> m_chainman;
+    std::shared_ptr<const Context> m_context;
+
+    ChainMan(std::unique_ptr<ChainstateManager> chainman, std::shared_ptr<const Context> context)
+        : m_chainman(std::move(chainman)), m_context(std::move(context)) {}
+};
+
 } // namespace
 
 struct btck_Transaction : Handle<btck_Transaction, std::shared_ptr<const CTransaction>> {};
@@ -372,6 +408,8 @@ struct btck_LoggingConnection : Handle<btck_LoggingConnection, LoggingConnection
 struct btck_ContextOptions : Handle<btck_ContextOptions, ContextOptions> {};
 struct btck_Context : Handle<btck_Context, std::shared_ptr<const Context>> {};
 struct btck_ChainParameters : Handle<btck_ChainParameters, std::unique_ptr<const CChainParams>> {};
+struct btck_ChainstateManagerOptions : Handle<btck_ChainstateManagerOptions, ChainstateManagerOptions> {};
+struct btck_ChainstateManager : Handle<btck_ChainstateManager, ChainMan> {};
 
 btck_Transaction* btck_transaction_create(const void* raw_transaction, size_t raw_transaction_len)
 {
@@ -632,3 +670,52 @@ void btck_context_destroy(btck_Context* context)
 {
     delete context;
 }
+
+btck_ChainstateManagerOptions* btck_chainstate_manager_options_create(const btck_Context* context, const char* data_dir, size_t data_dir_len, const char* blocks_dir, size_t blocks_dir_len)
+{
+    try {
+        fs::path abs_data_dir{fs::absolute(fs::PathFromString({data_dir, data_dir_len}))};
+        fs::create_directories(abs_data_dir);
+        fs::path abs_blocks_dir{fs::absolute(fs::PathFromString({blocks_dir, blocks_dir_len}))};
+        fs::create_directories(abs_blocks_dir);
+        return btck_ChainstateManagerOptions::create(btck_Context::get(context), abs_data_dir, abs_blocks_dir);
+    } catch (const std::exception& e) {
+        LogError("Failed to create chainstate manager options: %s", e.what());
+        return nullptr;
+    }
+}
+
+void btck_chainstate_manager_options_destroy(btck_ChainstateManagerOptions* options)
+{
+    delete options;
+}
+
+btck_ChainstateManager* btck_chainstate_manager_create(
+    const btck_ChainstateManagerOptions* chainman_opts)
+{
+    try {
+        auto& opts{btck_ChainstateManagerOptions::get(chainman_opts)};
+        LOCK(opts.m_mutex);
+        auto& context{opts.m_context};
+        auto chainman{std::make_unique<ChainstateManager>(*context->m_interrupt, opts.m_chainman_options, opts.m_blockman_options)};
+        return btck_ChainstateManager::create(std::move(chainman), context);
+    } catch (const std::exception& e) {
+        LogError("Failed to create chainstate manager: %s", e.what());
+        return nullptr;
+    }
+}
+
+void btck_chainstate_manager_destroy(btck_ChainstateManager* chainman)
+{
+    {
+        LOCK(btck_ChainstateManager::get(chainman).m_chainman->GetMutex());
+        for (Chainstate* chainstate : btck_ChainstateManager::get(chainman).m_chainman->GetAll()) {
+            if (chainstate->CanFlushToDisk()) {
+                chainstate->ForceFlushStateToDisk();
+                chainstate->ResetCoinsViews();
+            }
+        }
+    }
+
+    delete chainman;
+}
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index 4018710078a..065173b2789 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -165,6 +165,26 @@ typedef struct btck_Context btck_Context;
  */
 typedef struct btck_BlockTreeEntry btck_BlockTreeEntry;
 
+/**
+ * Opaque data structure for holding options for creating a new chainstate
+ * manager.
+ *
+ * The chainstate manager options are used to set some parameters for the
+ * chainstate manager. For now it just holds default options.
+ */
+typedef struct btck_ChainstateManagerOptions btck_ChainstateManagerOptions;
+
+/**
+ * Opaque data structure for holding a chainstate manager.
+ *
+ * The chainstate manager is the central object for doing validation tasks as
+ * well as retrieving data from the chain. Internally it is a complex data
+ * structure with diverse functionality.
+ *
+ * Its functionality will be more and more exposed in the future.
+ */
+typedef struct btck_ChainstateManager btck_ChainstateManager;
+
 /** Current sync state passed to tip changed callbacks. */
 typedef uint8_t btck_SynchronizationState;
 #define btck_SynchronizationState_INIT_REINDEX ((btck_SynchronizationState)(0))
@@ -671,6 +691,58 @@ BITCOINKERNEL_API void btck_context_destroy(btck_Context* context);
 
 ///@}
 
+/** @name ChainstateManagerOptions
+ * Functions for working with chainstate manager options.
+ */
+///@{
+
+/**
+ * @brief Create options for the chainstate manager.
+ *
+ * @param[in] context          Non-null, the created options and through it the chainstate manager will
+                               associate with this kernel context for the duration of their lifetimes.
+ * @param[in] data_directory   Non-null, path string of the directory containing the chainstate data.
+ *                             If the directory does not exist yet, it will be created.
+ * @param[in] blocks_directory Non-null, path string of the directory containing the block data. If
+ *                             the directory does not exist yet, it will be created.
+ * @return                     The allocated chainstate manager options, or null on error.
+ */
+BITCOINKERNEL_API btck_ChainstateManagerOptions* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_options_create(
+    const btck_Context* context,
+    const char* data_directory,
+    size_t data_directory_len,
+    const char* blocks_directory,
+    size_t blocks_directory_len) BITCOINKERNEL_ARG_NONNULL(1, 2);
+
+/**
+ * Destroy the chainstate manager options.
+ */
+BITCOINKERNEL_API void btck_chainstate_manager_options_destroy(btck_ChainstateManagerOptions* chainstate_manager_options);
+
+///@}
+
+/** @name ChainstateManager
+ * Functions for chainstate management.
+ */
+///@{
+
+/**
+ * @brief Create a chainstate manager. This is the main object for many
+ * validation tasks as well as for retrieving data from the chain. *
+ *
+ * @param[in] chainstate_manager_options Non-null, created by @ref btck_chainstate_manager_options_create.
+ * @return                               The allocated chainstate manager, or null on error.
+ */
+BITCOINKERNEL_API btck_ChainstateManager* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_create(
+    const btck_ChainstateManagerOptions* chainstate_manager_options) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Destroy the chainstate manager.
+ */
+BITCOINKERNEL_API void btck_chainstate_manager_destroy(btck_ChainstateManager* chainstate_manager);
+
+///@}
+
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index a2c2dcc5fce..0dd92542e25 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -11,6 +11,7 @@
 #include <memory>
 #include <span>
 #include <stdexcept>
+#include <string>
 #include <string_view>
 #include <type_traits>
 #include <utility>
@@ -618,6 +619,28 @@ public:
 
     Context()
         : Handle{btck_context_create(ContextOptions{}.get())} {}
+
+    friend class ChainstateManagerOptions;
+};
+
+class ChainstateManagerOptions : UniqueHandle<btck_ChainstateManagerOptions, btck_chainstate_manager_options_destroy>
+{
+public:
+    ChainstateManagerOptions(const Context& context, const std::string& data_dir, const std::string& blocks_dir)
+        : UniqueHandle{btck_chainstate_manager_options_create(context.get(), data_dir.c_str(), data_dir.length(), blocks_dir.c_str(), blocks_dir.length())}
+    {
+    }
+
+    friend class ChainMan;
+};
+
+class ChainMan : UniqueHandle<btck_ChainstateManager, btck_chainstate_manager_destroy>
+{
+public:
+    ChainMan(const Context& context, const ChainstateManagerOptions& chainman_opts)
+        : UniqueHandle{btck_chainstate_manager_create(chainman_opts.get())}
+    {
+    }
 };
 
 } // namespace btck
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index 6258bf69a95..f8b2ea78e84 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -11,15 +11,36 @@
 #include <charconv>
 #include <cstdint>
 #include <cstdlib>
+#include <filesystem>
 #include <iostream>
 #include <memory>
+#include <random>
 #include <ranges>
 #include <span>
+#include <string>
 #include <string_view>
 #include <vector>
 
 using namespace btck;
 
+std::string random_string(uint32_t length)
+{
+    const std::string chars = "0123456789"
+                              "abcdefghijklmnopqrstuvwxyz"
+                              "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+    static std::random_device rd;
+    static std::default_random_engine dre{rd()};
+    static std::uniform_int_distribution<> distribution(0, chars.size() - 1);
+
+    std::string random;
+    random.reserve(length);
+    for (uint32_t i = 0; i < length; i++) {
+        random += chars[distribution(dre)];
+    }
+    return random;
+}
+
 std::vector<std::byte> hex_string_to_byte_vec(std::string_view hex)
 {
     std::vector<std::byte> bytes;
@@ -60,6 +81,20 @@ public:
     }
 };
 
+struct TestDirectory {
+    std::filesystem::path m_directory;
+    TestDirectory(std::string directory_name)
+        : m_directory{std::filesystem::temp_directory_path() / (directory_name + random_string(16))}
+    {
+        std::filesystem::create_directories(m_directory);
+    }
+
+    ~TestDirectory()
+    {
+        std::filesystem::remove_all(m_directory);
+    }
+};
+
 class TestKernelNotifications : public KernelNotifications<TestKernelNotifications>
 {
 public:
@@ -437,3 +472,45 @@ BOOST_AUTO_TEST_CASE(btck_context_tests)
         Context context{options};
     }
 }
+
+Context create_context(std::shared_ptr<TestKernelNotifications> notifications, ChainType chain_type)
+{
+    ContextOptions options{};
+    ChainParams params{chain_type};
+    options.SetChainParams(params);
+    options.SetNotifications(notifications);
+    auto context{Context{options}};
+    return context;
+}
+
+BOOST_AUTO_TEST_CASE(btck_chainman_tests)
+{
+    btck_LoggingOptions logging_options = {
+        .log_timestamps = true,
+        .log_time_micros = true,
+        .log_threadnames = false,
+        .log_sourcelocations = false,
+        .always_print_category_levels = true,
+    };
+    Logger logger{std::make_unique<TestLog>(TestLog{}), logging_options};
+    auto test_directory{TestDirectory{"chainman_test_bitcoin_kernel"}};
+
+    { // test with default context
+        Context context{};
+        ChainstateManagerOptions chainman_opts{context, test_directory.m_directory.string(), (test_directory.m_directory / "blocks").string()};
+        ChainMan chainman{context, chainman_opts};
+    }
+
+    { // test with default context options
+        ContextOptions options{};
+        Context context{options};
+        ChainstateManagerOptions chainman_opts{context, test_directory.m_directory.string(), (test_directory.m_directory / "blocks").string()};
+        ChainMan chainman{context, chainman_opts};
+    }
+
+    auto notifications{std::make_shared<TestKernelNotifications>()};
+    auto context{create_context(notifications, ChainType::MAINNET)};
+
+    ChainstateManagerOptions chainman_opts{context, test_directory.m_directory.string(), (test_directory.m_directory / "blocks").string()};
+    ChainMan chainman{context, chainman_opts};
+}
diff --git a/test/lint/test_runner/src/main.rs b/test/lint/test_runner/src/main.rs
index ba5aaee793f..53d24ca4960 100644
--- a/test/lint/test_runner/src/main.rs
+++ b/test/lint/test_runner/src/main.rs
@@ -373,6 +373,7 @@ fn lint_std_filesystem() -> LintResult {
             "./src/",
             ":(exclude)src/ipc/libmultiprocess/",
             ":(exclude)src/util/fs.h",
+            ":(exclude)src/test/kernel/test_kernel.cpp",
         ])
         .status()
         .expect("command error")

From 783db175aa0eefb4342c0405556a14bf8bc221f3 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Sun, 17 Nov 2024 17:36:48 +0100
Subject: [PATCH 07/24] kernel: Add chainstate manager option for setting
 worker threads

Re-use the same pattern used for the context options. This allows users
to set the number of threads used in the validation thread pool.
---
 src/kernel/bitcoinkernel.cpp       |  6 ++++++
 src/kernel/bitcoinkernel.h         | 12 ++++++++++++
 src/kernel/bitcoinkernel_wrapper.h |  5 +++++
 src/test/kernel/test_kernel.cpp    |  1 +
 4 files changed, 24 insertions(+)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index 88fc9fbab04..b770cdd955c 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -685,6 +685,12 @@ btck_ChainstateManagerOptions* btck_chainstate_manager_options_create(const btck
     }
 }
 
+void btck_chainstate_manager_options_set_worker_threads_num(btck_ChainstateManagerOptions* opts, int worker_threads)
+{
+    LOCK(btck_ChainstateManagerOptions::get(opts).m_mutex);
+    btck_ChainstateManagerOptions::get(opts).m_chainman_options.worker_threads_num = worker_threads;
+}
+
 void btck_chainstate_manager_options_destroy(btck_ChainstateManagerOptions* options)
 {
     delete options;
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index 065173b2789..e5e5ea56e04 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -714,6 +714,18 @@ BITCOINKERNEL_API btck_ChainstateManagerOptions* BITCOINKERNEL_WARN_UNUSED_RESUL
     const char* blocks_directory,
     size_t blocks_directory_len) BITCOINKERNEL_ARG_NONNULL(1, 2);
 
+/**
+ * @brief Set the number of available worker threads used during validation.
+ *
+ * @param[in] chainstate_manager_options Non-null, options to be set.
+ * @param[in] worker_threads             The number of worker threads that should be spawned in the thread pool
+ *                                       used for validation. When set to 0 no parallel verification is done.
+ *                                       The value range is clamped internally between 0 and 15.
+ */
+BITCOINKERNEL_API void btck_chainstate_manager_options_set_worker_threads_num(
+    btck_ChainstateManagerOptions* chainstate_manager_options,
+    int worker_threads) BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * Destroy the chainstate manager options.
  */
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index 0dd92542e25..f67e9d7a96f 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -631,6 +631,11 @@ public:
     {
     }
 
+    void SetWorkerThreads(int worker_threads)
+    {
+        btck_chainstate_manager_options_set_worker_threads_num(get(), worker_threads);
+    }
+
     friend class ChainMan;
 };
 
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index f8b2ea78e84..74f162b5000 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -512,5 +512,6 @@ BOOST_AUTO_TEST_CASE(btck_chainman_tests)
     auto context{create_context(notifications, ChainType::MAINNET)};
 
     ChainstateManagerOptions chainman_opts{context, test_directory.m_directory.string(), (test_directory.m_directory / "blocks").string()};
+    chainman_opts.SetWorkerThreads(4);
     ChainMan chainman{context, chainman_opts};
 }

From 6b1ee824171d2b524aa8f4f8aa3cc44cbeaa59e1 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Wed, 29 May 2024 13:28:05 +0200
Subject: [PATCH 08/24] kernel: Add chainstate loading when instantiating a
 ChainstateManager

The library will now internally load the chainstate when a new
ChainstateManager is instantiated.

Options for controlling details of loading the chainstate will be added
over the next few commits.
---
 src/kernel/bitcoinkernel.cpp | 42 +++++++++++++++++++++++++++++++-----
 src/kernel/bitcoinkernel.h   |  3 ++-
 2 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index b770cdd955c..5bc7131290c 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -7,6 +7,7 @@
 #include <kernel/bitcoinkernel.h>
 
 #include <consensus/amount.h>
+#include <consensus/validation.h>
 #include <kernel/caches.h>
 #include <kernel/chainparams.h>
 #include <kernel/checks.h>
@@ -16,6 +17,7 @@
 #include <kernel/warning.h>
 #include <logging.h>
 #include <node/blockstorage.h>
+#include <node/chainstate.h>
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
 #include <script/script.h>
@@ -38,6 +40,7 @@
 #include <memory>
 #include <span>
 #include <string>
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -372,6 +375,7 @@ struct ChainstateManagerOptions {
     ChainstateManager::Options m_chainman_options GUARDED_BY(m_mutex);
     node::BlockManager::Options m_blockman_options GUARDED_BY(m_mutex);
     std::shared_ptr<const Context> m_context;
+    node::ChainstateLoadOptions m_chainstate_load_options GUARDED_BY(m_mutex);
 
     ChainstateManagerOptions(const std::shared_ptr<const Context>& context, const fs::path& data_dir, const fs::path& blocks_dir)
         : m_chainman_options{ChainstateManager::Options{
@@ -386,7 +390,7 @@ struct ChainstateManagerOptions {
                   .path = data_dir / "blocks" / "index",
                   .cache_bytes = kernel::CacheSizes{DEFAULT_KERNEL_CACHE}.block_tree_db,
               }}},
-          m_context{context}
+          m_context{context}, m_chainstate_load_options{node::ChainstateLoadOptions{}}
     {
     }
 };
@@ -699,16 +703,44 @@ void btck_chainstate_manager_options_destroy(btck_ChainstateManagerOptions* opti
 btck_ChainstateManager* btck_chainstate_manager_create(
     const btck_ChainstateManagerOptions* chainman_opts)
 {
+    auto& opts{btck_ChainstateManagerOptions::get(chainman_opts)};
+    std::unique_ptr<ChainstateManager> chainman;
     try {
-        auto& opts{btck_ChainstateManagerOptions::get(chainman_opts)};
         LOCK(opts.m_mutex);
-        auto& context{opts.m_context};
-        auto chainman{std::make_unique<ChainstateManager>(*context->m_interrupt, opts.m_chainman_options, opts.m_blockman_options)};
-        return btck_ChainstateManager::create(std::move(chainman), context);
+        chainman = std::make_unique<ChainstateManager>(*opts.m_context->m_interrupt, opts.m_chainman_options, opts.m_blockman_options);
     } catch (const std::exception& e) {
         LogError("Failed to create chainstate manager: %s", e.what());
         return nullptr;
     }
+
+    try {
+        const auto chainstate_load_opts{WITH_LOCK(opts.m_mutex, return opts.m_chainstate_load_options)};
+
+        kernel::CacheSizes cache_sizes{DEFAULT_KERNEL_CACHE};
+        auto [status, chainstate_err]{node::LoadChainstate(*chainman, cache_sizes, chainstate_load_opts)};
+        if (status != node::ChainstateLoadStatus::SUCCESS) {
+            LogError("Failed to load chain state from your data directory: %s", chainstate_err.original);
+            return nullptr;
+        }
+        std::tie(status, chainstate_err) = node::VerifyLoadedChainstate(*chainman, chainstate_load_opts);
+        if (status != node::ChainstateLoadStatus::SUCCESS) {
+            LogError("Failed to verify loaded chain state from your datadir: %s", chainstate_err.original);
+            return nullptr;
+        }
+
+        for (Chainstate* chainstate : WITH_LOCK(chainman->GetMutex(), return chainman->GetAll())) {
+            BlockValidationState state;
+            if (!chainstate->ActivateBestChain(state, nullptr)) {
+                LogError("Failed to connect best block: %s", state.ToString());
+                return nullptr;
+            }
+        }
+    } catch (const std::exception& e) {
+        LogError("Failed to load chainstate: %s", e.what());
+        return nullptr;
+    }
+
+    return btck_ChainstateManager::create(std::move(chainman), opts.m_context);
 }
 
 void btck_chainstate_manager_destroy(btck_ChainstateManager* chainman)
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index e5e5ea56e04..cf9653ee1b4 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -740,7 +740,8 @@ BITCOINKERNEL_API void btck_chainstate_manager_options_destroy(btck_ChainstateMa
 
 /**
  * @brief Create a chainstate manager. This is the main object for many
- * validation tasks as well as for retrieving data from the chain. *
+ * validation tasks as well as for retrieving data from the chain and
+ * interacting with its chainstate and indexes.
  *
  * @param[in] chainstate_manager_options Non-null, created by @ref btck_chainstate_manager_options_create.
  * @return                               The allocated chainstate manager, or null on error.

From 42c106df05e01cd943f0dcafe389f4aa267ea618 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Mon, 17 Jun 2024 22:50:23 +0200
Subject: [PATCH 09/24] kernel: Add block validation to C header

The added function allows the user process and validate a given block
with the chainstate manager. The *_process_block(...) function does some
preliminary checks on the block before passing it to
`ProcessNewBlock(...)`. These are similar to the checks in the
`submitblock()` rpc.

Richer processing of the block validation result will be made available
in the following commits through the validation interface.

The commits also adds a utility for deserializing a `CBlock`
(`kernel_block_create()`) that may then be passed to the library for
processing.

The tests exercise the function for both mainnet and regtest. The
commit also adds the data of 206 regtest blocks (some blocks also
contain transactions).
---
 src/kernel/bitcoinkernel.cpp       |  56 +++-
 src/kernel/bitcoinkernel.h         |  74 +++++
 src/kernel/bitcoinkernel_wrapper.h |  45 ++++
 src/test/kernel/block_data.h       | 418 +++++++++++++++++++++++++++++
 src/test/kernel/test_kernel.cpp    | 107 ++++++++
 5 files changed, 698 insertions(+), 2 deletions(-)
 create mode 100644 src/test/kernel/block_data.h

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index 5bc7131290c..acc5cad69ce 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -6,6 +6,7 @@
 
 #include <kernel/bitcoinkernel.h>
 
+#include <chain.h>
 #include <consensus/amount.h>
 #include <consensus/validation.h>
 #include <kernel/caches.h>
@@ -18,6 +19,7 @@
 #include <logging.h>
 #include <node/blockstorage.h>
 #include <node/chainstate.h>
+#include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
 #include <script/script.h>
@@ -25,6 +27,7 @@
 #include <streams.h>
 #include <sync.h>
 #include <tinyformat.h>
+#include <uint256.h>
 #include <util/fs.h>
 #include <util/result.h>
 #include <util/signalinterrupt.h>
@@ -44,8 +47,6 @@
 #include <utility>
 #include <vector>
 
-class CBlockIndex;
-
 // Define G_TRANSLATION_FUN symbol in libbitcoinkernel library so users of the
 // library aren't required to export this symbol
 extern const std::function<std::string(const char*)> G_TRANSLATION_FUN{nullptr};
@@ -133,6 +134,7 @@ struct Handle {
 } // namespace
 
 struct btck_BlockTreeEntry: Handle<btck_BlockTreeEntry, CBlockIndex> {};
+struct btck_Block : Handle<btck_Block, std::shared_ptr<const CBlock>> {};
 
 namespace {
 
@@ -757,3 +759,53 @@ void btck_chainstate_manager_destroy(btck_ChainstateManager* chainman)
 
     delete chainman;
 }
+
+btck_Block* btck_block_create(const void* raw_block, size_t raw_block_length)
+{
+    auto block{std::make_shared<CBlock>()};
+
+    DataStream stream{std::span{reinterpret_cast<const std::byte*>(raw_block), raw_block_length}};
+
+    try {
+        stream >> TX_WITH_WITNESS(*block);
+    } catch (...) {
+        LogDebug(BCLog::KERNEL, "Block decode failed.");
+        return nullptr;
+    }
+
+    return btck_Block::create(block);
+}
+
+btck_Block* btck_block_copy(const btck_Block* block)
+{
+    return btck_Block::copy(block);
+}
+
+size_t btck_block_count_transactions(const btck_Block* block)
+{
+    return btck_Block::get(block)->vtx.size();
+}
+
+const btck_Transaction* btck_block_get_transaction_at(const btck_Block* block, size_t index)
+{
+    assert(index < btck_Block::get(block)->vtx.size());
+    return btck_Transaction::ref(&btck_Block::get(block)->vtx[index]);
+}
+
+void btck_block_destroy(btck_Block* block)
+{
+    delete block;
+}
+
+int btck_chainstate_manager_process_block(
+    btck_ChainstateManager* chainman,
+    const btck_Block* block,
+    int* _new_block)
+{
+    bool new_block;
+    auto result = btck_ChainstateManager::get(chainman).m_chainman->ProcessNewBlock(btck_Block::get(block), /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/&new_block);
+    if (_new_block) {
+        *_new_block = new_block ? 1 : 0;
+    }
+    return result ? 0 : -1;
+}
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index cf9653ee1b4..5c2b51390c5 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -185,6 +185,11 @@ typedef struct btck_ChainstateManagerOptions btck_ChainstateManagerOptions;
  */
 typedef struct btck_ChainstateManager btck_ChainstateManager;
 
+/**
+ * Opaque data structure for holding a block.
+ */
+typedef struct btck_Block btck_Block;
+
 /** Current sync state passed to tip changed callbacks. */
 typedef uint8_t btck_SynchronizationState;
 #define btck_SynchronizationState_INIT_REINDEX ((btck_SynchronizationState)(0))
@@ -749,6 +754,23 @@ BITCOINKERNEL_API void btck_chainstate_manager_options_destroy(btck_ChainstateMa
 BITCOINKERNEL_API btck_ChainstateManager* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_create(
     const btck_ChainstateManagerOptions* chainstate_manager_options) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Process and validate the passed in block with the chainstate
+ * manager. Processing first does checks on the block, and if these passed,
+ * saves it to disk. It then validates the block against the utxo set. If it is
+ * valid, the chain is extended with it. The return value is not indicative of
+ * the block's validity.
+ *
+ * @param[in] chainstate_manager Non-null.
+ * @param[in] block              Non-null, block to be validated.
+ * @param[out] new_block         Nullable, will be set to 1 if this block was not processed before.
+ * @return                       0 if processing the block was successful. Will also return 0 for valid, but duplicate blocks.
+ */
+BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_process_block(
+    btck_ChainstateManager* chainstate_manager,
+    const btck_Block* block,
+    int* new_block) BITCOINKERNEL_ARG_NONNULL(1, 2, 3);
+
 /**
  * Destroy the chainstate manager.
  */
@@ -756,6 +778,58 @@ BITCOINKERNEL_API void btck_chainstate_manager_destroy(btck_ChainstateManager* c
 
 ///@}
 
+/** @name Block
+ * Functions for working with blocks.
+ */
+///@{
+
+/**
+ * @brief Parse a serialized raw block into a new block object.
+ *
+ * @param[in] raw_block     Non-null, serialized block.
+ * @param[in] raw_block_len Length of the serialized block.
+ * @return                  The allocated block, or null on error.
+ */
+BITCOINKERNEL_API btck_Block* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_create(
+    const void* raw_block, size_t raw_block_len) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Copy a block. Blocks are reference counted, so this just increments
+ * the reference count.
+ *
+ * @param[in] block Non-null.
+ * @return          The copied block.
+ */
+BITCOINKERNEL_API btck_Block* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_copy(
+    const btck_Block* block) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Count the number of transactions contained in a block.
+ *
+ * @param[in] block Non-null.
+ * @return          The number of transactions in the block.
+ */
+BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_count_transactions(
+    const btck_Block* block) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Get the transaction at the provided index. The returned transaction
+ * is not owned and depends on the lifetime of the block.
+ *
+ * @param[in] block             Non-null.
+ * @param[in] transaction_index The index of the transaction to be retrieved.
+ * @return                      The transaction.
+ */
+BITCOINKERNEL_API const btck_Transaction* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_get_transaction_at(
+    const btck_Block* block, size_t transaction_index) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Destroy the block.
+ */
+BITCOINKERNEL_API void btck_block_destroy(btck_Block* block);
+
+///@}
+
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index f67e9d7a96f..5ec6fada44d 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -463,11 +463,20 @@ public:
     }
 };
 
+class TransactionView : public View<btck_Transaction>, public TransactionApi<TransactionView>
+{
+public:
+    explicit TransactionView(const btck_Transaction* ptr) : View{ptr} {}
+};
+
 class Transaction : public Handle<btck_Transaction, btck_transaction_copy, btck_transaction_destroy>, public TransactionApi<Transaction>
 {
 public:
     explicit Transaction(std::span<const std::byte> raw_transaction)
         : Handle{btck_transaction_create(raw_transaction.data(), raw_transaction.size())} {}
+
+    Transaction(const TransactionView& view)
+        : Handle{view} {}
 };
 
 template <typename Derived>
@@ -499,6 +508,34 @@ bool ScriptPubkeyApi<Derived>::Verify(int64_t amount,
     return result == 1;
 }
 
+class Block : public Handle<btck_Block, btck_block_copy, btck_block_destroy>
+{
+public:
+    Block(const std::span<const std::byte> raw_block)
+        : Handle{btck_block_create(raw_block.data(), raw_block.size())}
+    {
+    }
+
+    Block(btck_Block* block) : Handle{block} {}
+
+    size_t CountTransactions() const
+    {
+        return btck_block_count_transactions(get());
+    }
+
+    TransactionView GetTransaction(size_t index) const
+    {
+        return TransactionView{btck_block_get_transaction_at(get(), index)};
+    }
+
+    auto Transactions() const
+    {
+        return Range<Block, &Block::CountTransactions, &Block::GetTransaction>{*this};
+    }
+
+    friend class ChainMan;
+};
+
 void logging_disable()
 {
     btck_logging_disable();
@@ -646,6 +683,14 @@ public:
         : UniqueHandle{btck_chainstate_manager_create(chainman_opts.get())}
     {
     }
+
+    bool ProcessBlock(const Block& block, bool* new_block)
+    {
+        int _new_block;
+        int res = btck_chainstate_manager_process_block(get(), block.get(), &_new_block);
+        if (new_block) *new_block = _new_block == 1;
+        return res == 0;
+    }
 };
 
 } // namespace btck
diff --git a/src/test/kernel/block_data.h b/src/test/kernel/block_data.h
new file mode 100644
index 00000000000..559ec1550b9
--- /dev/null
+++ b/src/test/kernel/block_data.h
@@ -0,0 +1,418 @@
+#ifndef BITCOIN_TEST_KERNEL_BLOCK_DATA_H
+#define BITCOIN_TEST_KERNEL_BLOCK_DATA_H
+#include <vector>
+static const std::vector<std::vector<unsigned char>> REGTEST_BLOCK_DATA {
+{0x00, 0x00, 0x00, 0x20, 0x06, 0x22, 0x6e, 0x46, 0x11, 0x1a, 0x0b, 0x59, 0xca, 0xaf, 0x12, 0x60, 0x43, 0xeb, 0x5b, 0xbf, 0x28, 0xc3, 0x4f, 0x3a, 0x5e, 0x33, 0x2a, 0x1f, 0xc7, 0xb2, 0xb7, 0x3c, 0xf1, 0x88, 0x91, 0x0f, 0x29, 0x5b, 0xad, 0xc0, 0xbd, 0xd9, 0xa2, 0xbc, 0x09, 0x55, 0xd1, 0x2f, 0x33, 0x74, 0x91, 0xea, 0xe4, 0xc8, 0x7b, 0xa4, 0x66, 0x00, 0x78, 0xc0, 0x15, 0x63, 0x10, 0x28, 0x4d, 0x47, 0xc6, 0xff, 0x9a, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x51, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xa6, 0x29, 0xda, 0x61, 0xcc, 0xd6, 0xc9, 0xde, 0x14, 0xdd, 0x22, 0xd4, 0xdc, 0xf0, 0x6a, 0xc4, 0xb9, 0x88, 0x28, 0x80, 0x1f, 0xb5, 0x82, 0x75, 0xaf, 0x1e, 0xd2, 0xc8, 0x9e, 0x36, 0x1b, 0x79, 0x67, 0x7d, 0xae, 0xdb, 0x5f, 0xc7, 0x78, 0x1c, 0x59, 0x07, 0xa8, 0x81, 0x33, 0xcd, 0x46, 0x1b, 0x48, 0x65, 0xe9, 0xa4, 0x88, 0x1f, 0xec, 0xfb, 0x36, 0x23, 0x04, 0xad, 0x18, 0x06, 0xac, 0xf3, 0xa7, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x52, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x62, 0x17, 0x16, 0xdb, 0xbd, 0x2d, 0x41, 0x09, 0xec, 0xf9, 0x5e, 0x3a, 0xd1, 0x4f, 0x2e, 0x20, 0x5c, 0xc2, 0xdc, 0x52, 0xe2, 0x86, 0xe1, 0x27, 0x00, 0x9b, 0x89, 0x41, 0xd2, 0x55, 0x49, 0x5a, 0x16, 0xbb, 0x39, 0xe1, 0xed, 0x66, 0xdc, 0xf6, 0x00, 0xfd, 0x7e, 0xab, 0xd1, 0xb8, 0xee, 0x77, 0xec, 0x89, 0x4a, 0x77, 0xc2, 0xea, 0xc0, 0xdc, 0xc3, 0xef, 0x2a, 0x44, 0x00, 0x70, 0x7f, 0x56, 0xa7, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x53, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x4b, 0x27, 0x2f, 0xa0, 0x40, 0x08, 0x18, 0x32, 0x59, 0x78, 0x16, 0x10, 0x31, 0xfe, 0xd2, 0x50, 0xa9, 0xd9, 0x71, 0x34, 0x71, 0xc9, 0xb9, 0x9b, 0xe3, 0xd1, 0x0e, 0x23, 0x50, 0xbf, 0xd6, 0x32, 0xcc, 0xf3, 0x3d, 0xfd, 0x71, 0x4c, 0xe2, 0x43, 0xa4, 0x81, 0x50, 0xfc, 0xf6, 0x28, 0x1a, 0xc3, 0x56, 0x3d, 0xe5, 0x41, 0x81, 0x12, 0x60, 0x6e, 0xe2, 0xcc, 0x09, 0x63, 0x2f, 0x1e, 0xa4, 0x06, 0xa8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x54, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x0e, 0x99, 0xbd, 0x49, 0x68, 0xd4, 0xc5, 0xe5, 0x88, 0x87, 0xc3, 0xa6, 0xf1, 0xb5, 0xe3, 0x83, 0x0e, 0xed, 0x6a, 0xed, 0x63, 0x5a, 0x1d, 0x72, 0x75, 0xb0, 0x36, 0x1d, 0x9d, 0x69, 0xc2, 0x43, 0x94, 0xc1, 0x1b, 0x24, 0x14, 0x97, 0x70, 0x58, 0xcb, 0x5f, 0xf8, 0x28, 0xa1, 0x3c, 0x1e, 0x28, 0xb3, 0x42, 0xbb, 0x94, 0x7c, 0x47, 0xf8, 0xb1, 0xfc, 0x1c, 0x88, 0x86, 0xc6, 0x35, 0x5e, 0x03, 0xa8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x04, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x55, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x6f, 0xe9, 0xa1, 0xea, 0x5c, 0x1b, 0x6c, 0xb5, 0xf0, 0xa2, 0x13, 0x9c, 0xb1, 0x87, 0xed, 0x8c, 0x34, 0x77, 0x37, 0x8f, 0x92, 0x83, 0x89, 0x99, 0xf1, 0x07, 0xf9, 0x12, 0xde, 0x0b, 0xf9, 0x2b, 0x4d, 0x73, 0x85, 0xd0, 0xa8, 0x4e, 0x58, 0xf7, 0xf8, 0xd8, 0xd5, 0x8e, 0x6a, 0xec, 0xff, 0x09, 0x28, 0xb0, 0xc8, 0xfc, 0x13, 0x00, 0x9a, 0xb0, 0xfa, 0xae, 0x02, 0x65, 0x0f, 0x97, 0x26, 0xec, 0xa8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x56, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x7d, 0xd7, 0x3a, 0x99, 0x5a, 0x00, 0xc5, 0xba, 0xbb, 0x1d, 0x30, 0x84, 0x21, 0x6e, 0x60, 0x77, 0x75, 0xa0, 0x3b, 0x98, 0x5a, 0xe2, 0x59, 0x26, 0xda, 0xad, 0x86, 0x30, 0x7b, 0x04, 0x23, 0x57, 0x13, 0xe1, 0x13, 0xfa, 0x98, 0xf8, 0x65, 0x6f, 0xa8, 0x3b, 0x8f, 0x91, 0x12, 0x4a, 0x8f, 0x98, 0x8a, 0xb8, 0x26, 0x13, 0x83, 0x58, 0xcb, 0xc3, 0xa9, 0xbe, 0x92, 0x16, 0xbe, 0x01, 0x94, 0xd8, 0xa8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x06, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x57, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x4f, 0x6b, 0x4f, 0xdd, 0x4e, 0x99, 0xaa, 0x10, 0xa7, 0x24, 0xcb, 0xed, 0xde, 0xfe, 0x32, 0x3f, 0x00, 0x42, 0xf4, 0xa3, 0xf6, 0xe3, 0xbd, 0x05, 0x7f, 0xd4, 0xbd, 0x7a, 0x5b, 0x3d, 0xed, 0x6f, 0x71, 0x03, 0x65, 0x15, 0x7e, 0xd1, 0x7e, 0x65, 0xcd, 0xfd, 0x6e, 0x4a, 0x0e, 0xe0, 0xc7, 0x3c, 0xfb, 0x58, 0x2c, 0xb1, 0x4d, 0xbb, 0x87, 0x9d, 0xb7, 0x46, 0x56, 0x82, 0xfe, 0xdb, 0x68, 0x68, 0xa9, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x58, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x5b, 0x86, 0x72, 0x2a, 0x83, 0x56, 0x30, 0x52, 0x26, 0xf2, 0x36, 0xb6, 0x6d, 0x49, 0x44, 0x7b, 0x77, 0x12, 0x36, 0xd9, 0x1a, 0x76, 0x8c, 0xf9, 0xbc, 0x07, 0x73, 0xad, 0xdf, 0xcd, 0x1a, 0x3e, 0x20, 0x3d, 0x91, 0xdd, 0x64, 0x72, 0x10, 0xa0, 0x31, 0x04, 0x6c, 0xfc, 0xcd, 0x09, 0x9e, 0xdb, 0xa9, 0x4b, 0x5c, 0xb0, 0x20, 0x3a, 0xb1, 0xe7, 0xc2, 0x08, 0x15, 0x8c, 0x1c, 0x04, 0xd7, 0xee, 0xa9, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x59, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xbc, 0x72, 0xfc, 0xe0, 0xab, 0x31, 0x96, 0xfd, 0x3b, 0x49, 0xbe, 0x9c, 0xf4, 0x66, 0x97, 0x00, 0xf9, 0xaa, 0x66, 0xcf, 0x25, 0x7f, 0x04, 0x6d, 0xce, 0xf1, 0x75, 0xbb, 0x78, 0xa0, 0x79, 0x21, 0x9f, 0x52, 0x57, 0x5c, 0xd5, 0xc0, 0xc9, 0x3b, 0x5b, 0x37, 0xcf, 0x93, 0x77, 0x23, 0x0c, 0x0f, 0x4d, 0xd6, 0x20, 0x69, 0xfc, 0xc6, 0xdd, 0xab, 0x1a, 0x0c, 0xf3, 0x5e, 0xc1, 0xc4, 0x40, 0xee, 0xa9, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x5a, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xf9, 0xe0, 0x9a, 0x49, 0x78, 0x0b, 0x8e, 0x3a, 0xe1, 0xb5, 0xe0, 0xda, 0x63, 0x88, 0x7e, 0x81, 0x52, 0x8c, 0xed, 0xe0, 0xa0, 0x52, 0xfc, 0x0c, 0xe7, 0xe7, 0xfe, 0x44, 0xad, 0x09, 0xee, 0x4b, 0x67, 0x6a, 0x90, 0xf9, 0x74, 0x80, 0xef, 0x4e, 0x44, 0x73, 0x35, 0xf1, 0xb9, 0x37, 0x6c, 0x94, 0x43, 0x81, 0xfb, 0x06, 0xd6, 0x9b, 0x77, 0x8a, 0x47, 0x24, 0x8e, 0x57, 0x60, 0xde, 0xdf, 0x62, 0xa9, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x5b, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x8b, 0xfa, 0xc2, 0x2a, 0x1b, 0x80, 0x12, 0x18, 0xb5, 0x5c, 0xbd, 0x1a, 0x36, 0xc8, 0x6b, 0xa7, 0x07, 0xd4, 0x95, 0xb5, 0x2d, 0x96, 0x8f, 0xe2, 0x4a, 0x89, 0xef, 0x43, 0x0c, 0x6f, 0x9c, 0x05, 0x41, 0x9a, 0x27, 0x54, 0xa9, 0x0f, 0x35, 0xeb, 0xf6, 0x99, 0x28, 0x8a, 0xdf, 0xc7, 0x15, 0x68, 0x25, 0x2f, 0xed, 0xf4, 0x6a, 0x2b, 0x73, 0x1c, 0x2c, 0xc7, 0x87, 0xd5, 0x5e, 0x44, 0xe3, 0xde, 0xa9, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x5c, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xda, 0x91, 0xc8, 0xb0, 0xa3, 0x77, 0x2d, 0xe6, 0xa7, 0x94, 0xc9, 0xbd, 0x40, 0xcf, 0x7c, 0x1f, 0x8b, 0x21, 0xfa, 0xc9, 0x1f, 0x99, 0x49, 0x0e, 0x7d, 0x99, 0x5d, 0x7d, 0x0b, 0xd5, 0x2a, 0x4f, 0x69, 0xad, 0x11, 0xd9, 0xc3, 0x47, 0xc0, 0xbf, 0x88, 0x43, 0x0b, 0x12, 0x8b, 0x39, 0xf2, 0x7b, 0x95, 0x4f, 0xfc, 0xd4, 0x8b, 0xc3, 0x85, 0x01, 0xeb, 0xa0, 0xa9, 0x9d, 0xff, 0xb7, 0x96, 0x9b, 0xa9, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x5d, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x39, 0x56, 0xd8, 0xb7, 0x2a, 0x0b, 0x1c, 0x7c, 0x1d, 0x43, 0x68, 0x09, 0x5f, 0x6c, 0x1d, 0xb6, 0x05, 0x73, 0xc5, 0x08, 0x27, 0x83, 0x0b, 0x64, 0x8a, 0xd2, 0xd6, 0x74, 0x1d, 0x41, 0x94, 0x7c, 0x48, 0xe9, 0xd0, 0x57, 0xff, 0x73, 0x26, 0x02, 0x04, 0x2b, 0xb4, 0x69, 0x33, 0x56, 0x82, 0x92, 0xbd, 0x57, 0xe7, 0x67, 0x61, 0x27, 0x3b, 0x7a, 0xf1, 0x78, 0xba, 0xf9, 0x26, 0xce, 0xbe, 0x60, 0xaa, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x5e, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x9c, 0x42, 0x49, 0x92, 0x5f, 0xa4, 0x9b, 0xdd, 0xcd, 0x6f, 0x09, 0x17, 0xf8, 0xc6, 0x44, 0x4d, 0x89, 0x9d, 0x2d, 0x95, 0x8c, 0x65, 0xe3, 0x3d, 0xa4, 0x50, 0xe2, 0x56, 0x87, 0xd4, 0x6c, 0x4a, 0x8e, 0xfc, 0xab, 0x0b, 0xcc, 0xe7, 0xa6, 0xb2, 0x24, 0x85, 0x59, 0x8a, 0x2e, 0xb9, 0x28, 0x09, 0x22, 0x62, 0xc9, 0x5f, 0x2e, 0xa2, 0x33, 0xbe, 0xab, 0x34, 0x30, 0x44, 0x01, 0x32, 0x69, 0xdd, 0xaa, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x5f, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x57, 0xd9, 0xcf, 0x49, 0x6a, 0x6a, 0xd8, 0x59, 0xd1, 0xea, 0x07, 0x87, 0x2d, 0x52, 0x52, 0xa2, 0x3b, 0xbb, 0x53, 0x8b, 0xc7, 0xd1, 0xb0, 0x8c, 0x8d, 0x9f, 0x09, 0x74, 0xa8, 0x5e, 0x5e, 0x02, 0xb3, 0xdb, 0x6b, 0x3f, 0x80, 0x92, 0x0b, 0xbe, 0x3b, 0x22, 0xaf, 0x1b, 0xe2, 0xe9, 0xaa, 0xad, 0xcf, 0x80, 0xa1, 0x54, 0xef, 0xaa, 0xff, 0xdb, 0xe4, 0x90, 0xdf, 0xac, 0xb4, 0xd3, 0xa4, 0x51, 0xaa, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x60, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xb6, 0xfc, 0x1a, 0x61, 0xf7, 0xbe, 0x52, 0x63, 0x3d, 0x0a, 0x4b, 0x4c, 0x4c, 0x19, 0xf7, 0x71, 0xf1, 0x0b, 0xee, 0x3f, 0xc5, 0x65, 0x88, 0x43, 0x23, 0x91, 0xc5, 0xe9, 0x7b, 0x77, 0x6f, 0x73, 0x8a, 0xd2, 0xba, 0x58, 0xd0, 0x60, 0x82, 0xeb, 0xd0, 0x0d, 0x23, 0x0f, 0x18, 0xad, 0xc6, 0xff, 0x1b, 0x93, 0xa1, 0xd3, 0x17, 0x4a, 0xe3, 0x8a, 0x06, 0x18, 0x24, 0x20, 0xb4, 0x2f, 0xdc, 0x3f, 0xaa, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x11, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xd8, 0x5d, 0x1b, 0xf8, 0x80, 0xc7, 0x99, 0x0a, 0x81, 0xb9, 0xe0, 0x26, 0x7b, 0x68, 0xa2, 0x28, 0xb4, 0x8c, 0xb6, 0x48, 0x45, 0xa5, 0x80, 0x14, 0x3e, 0x82, 0xbd, 0x66, 0x3d, 0x0a, 0x09, 0x78, 0x18, 0x5f, 0xd9, 0x5f, 0x0b, 0xaa, 0x50, 0xfb, 0x47, 0xa7, 0x4a, 0xa8, 0xce, 0xf8, 0xc1, 0x39, 0x9c, 0x29, 0x34, 0x94, 0xb4, 0x30, 0x12, 0xd6, 0x3d, 0x96, 0x41, 0x05, 0xbf, 0x00, 0x93, 0xfb, 0xaa, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x12, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x68, 0xff, 0xad, 0xd1, 0x9d, 0x02, 0x80, 0xc4, 0x5e, 0xd8, 0xf0, 0xb7, 0x59, 0x0d, 0xd7, 0x5f, 0xed, 0x9c, 0x10, 0x09, 0xe0, 0x47, 0x5d, 0x46, 0x68, 0xa4, 0x0d, 0x2e, 0x14, 0x3b, 0xab, 0x66, 0x9b, 0x70, 0x92, 0x04, 0x4a, 0x52, 0xf2, 0x17, 0x75, 0x65, 0xd2, 0x65, 0xab, 0xe1, 0x23, 0x45, 0xdb, 0x9f, 0xe2, 0x54, 0x7d, 0xc3, 0xe3, 0xcb, 0x38, 0x3b, 0x44, 0x8d, 0xa6, 0x33, 0xb1, 0xb4, 0xaa, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x13, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x97, 0xdc, 0x68, 0xfc, 0x9d, 0x81, 0x18, 0x3e, 0x84, 0x44, 0x8a, 0xf9, 0x57, 0xc1, 0x46, 0x5f, 0x56, 0x9c, 0xac, 0x8f, 0xb6, 0x5c, 0x07, 0x4c, 0x84, 0x5d, 0x64, 0xf1, 0x9b, 0xd5, 0x54, 0x10, 0x41, 0x71, 0xf6, 0x7f, 0xbd, 0x23, 0x99, 0x99, 0xb7, 0x4f, 0xdc, 0xee, 0xe3, 0x5c, 0xcc, 0x71, 0xfc, 0x59, 0xef, 0x34, 0xae, 0x33, 0x2d, 0xfd, 0x14, 0x55, 0x2a, 0x5d, 0x8a, 0xcb, 0x54, 0xfc, 0xab, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x14, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xfa, 0x4a, 0xf9, 0xa0, 0xfc, 0x0b, 0x0e, 0x9a, 0x0e, 0xa5, 0x6e, 0xf4, 0x05, 0x7a, 0x1a, 0x63, 0xe2, 0x8a, 0xf0, 0xdf, 0x08, 0x99, 0x33, 0x1b, 0xb0, 0x75, 0xe5, 0x39, 0xec, 0x56, 0xed, 0x67, 0x9c, 0x4c, 0x2a, 0xd7, 0xa5, 0x3c, 0xa7, 0xb1, 0xf3, 0xb7, 0xef, 0x31, 0xbf, 0x7d, 0x58, 0x5f, 0x1a, 0xd9, 0x51, 0x1b, 0xdf, 0x22, 0x07, 0x9b, 0x91, 0xb0, 0x03, 0x75, 0x06, 0xb1, 0x24, 0x89, 0xab, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x15, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x2d, 0x10, 0x95, 0x3d, 0xee, 0x90, 0x89, 0xd3, 0x92, 0x0d, 0xe4, 0xd1, 0xb7, 0x49, 0x37, 0x24, 0xd7, 0x03, 0x56, 0xdf, 0x3c, 0x85, 0x7c, 0x7d, 0x68, 0xad, 0x4b, 0x2d, 0x80, 0x6f, 0xfa, 0x4c, 0xc7, 0x87, 0x1c, 0x5e, 0xa1, 0x75, 0xf0, 0xee, 0xed, 0x32, 0xfe, 0xd6, 0x5a, 0xd3, 0x9a, 0xff, 0x54, 0x3f, 0xf5, 0x6d, 0xa5, 0x64, 0xb9, 0x25, 0x13, 0xd2, 0x93, 0xc8, 0x1e, 0xd4, 0x91, 0x10, 0xab, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x16, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xfb, 0x21, 0xd2, 0xef, 0xf5, 0x0f, 0x7c, 0xa1, 0xbd, 0xd3, 0xcc, 0x07, 0x23, 0xea, 0x65, 0xee, 0x39, 0x83, 0x60, 0x12, 0x63, 0x53, 0xf0, 0x03, 0xd6, 0xcb, 0x3c, 0xcd, 0xed, 0xb6, 0x28, 0x0a, 0xc6, 0xf4, 0x09, 0xe9, 0xaa, 0x8d, 0xeb, 0xfb, 0x95, 0xa5, 0x9e, 0x6e, 0xcb, 0x9a, 0xf6, 0x57, 0x72, 0x6d, 0x9d, 0xdc, 0xd0, 0xbd, 0x1f, 0x1a, 0xc2, 0x4a, 0x8e, 0xaf, 0xb9, 0xb9, 0x47, 0x14, 0xab, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x17, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x5f, 0x4c, 0x34, 0x5d, 0xde, 0xf7, 0x2b, 0x4e, 0xf5, 0x05, 0x8c, 0xae, 0xac, 0xc0, 0x70, 0x0a, 0x66, 0xcc, 0x39, 0xea, 0x3c, 0x1a, 0x2a, 0x18, 0xc3, 0x17, 0x64, 0x8c, 0xab, 0xf8, 0xdc, 0x40, 0x2c, 0xc8, 0x3f, 0x2d, 0x67, 0xa4, 0x67, 0xa8, 0x71, 0x7a, 0xa1, 0x87, 0x9c, 0x41, 0xc5, 0x67, 0x7f, 0x48, 0x0c, 0xcb, 0xec, 0x5a, 0x8e, 0x80, 0x16, 0xf1, 0xf9, 0xcc, 0xd5, 0x6a, 0xaf, 0xc0, 0xab, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x18, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x31, 0x04, 0x33, 0xad, 0x61, 0x23, 0xb7, 0xd5, 0xd9, 0xab, 0xb3, 0xbb, 0xac, 0x99, 0xaa, 0x34, 0x2b, 0xbf, 0xd5, 0x00, 0x22, 0x6f, 0xb0, 0x71, 0x6a, 0xff, 0x55, 0xf3, 0x69, 0x9f, 0x35, 0x3f, 0x95, 0xc4, 0x31, 0x68, 0xd3, 0x37, 0x8b, 0x78, 0x87, 0xa2, 0xd1, 0xa2, 0x47, 0x43, 0xcf, 0x65, 0x7c, 0x91, 0x53, 0x9d, 0x41, 0x73, 0x66, 0xf2, 0x7b, 0xe4, 0x0c, 0xdc, 0x63, 0xa6, 0x01, 0xd3, 0xab, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x19, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xbf, 0xc0, 0x94, 0x7d, 0xe2, 0xb6, 0xad, 0xe4, 0x58, 0x53, 0x80, 0xf9, 0x4b, 0xee, 0xae, 0xcc, 0xef, 0x09, 0x26, 0x0f, 0x0f, 0x1d, 0xbb, 0x8c, 0x7d, 0xab, 0xad, 0x11, 0xeb, 0x32, 0xc9, 0x7e, 0x4b, 0x02, 0x9e, 0x0f, 0x31, 0x09, 0xe3, 0x78, 0x89, 0xb0, 0xec, 0xed, 0x5a, 0x40, 0xe1, 0xb9, 0x19, 0x4d, 0xf4, 0x69, 0x88, 0x37, 0x50, 0x64, 0x6d, 0x0a, 0xcb, 0x81, 0x45, 0xa4, 0xb2, 0x87, 0xac, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x1a, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x3b, 0x81, 0x93, 0xf8, 0xff, 0x6a, 0x02, 0xb8, 0x8c, 0xd4, 0x64, 0xcf, 0xfd, 0xa6, 0x35, 0x91, 0xcb, 0x17, 0x86, 0xb1, 0x5b, 0x9e, 0x82, 0x58, 0xf6, 0x03, 0x27, 0xf6, 0x39, 0x93, 0xda, 0x03, 0x4d, 0x96, 0xfa, 0x8c, 0x63, 0x2d, 0xa4, 0x73, 0xf2, 0xab, 0xcd, 0x00, 0x11, 0x84, 0xd1, 0x81, 0x27, 0x09, 0xed, 0x52, 0xe9, 0xc2, 0x58, 0x53, 0x08, 0xb2, 0x87, 0x43, 0xab, 0x75, 0x08, 0xe1, 0xac, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x1b, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x4f, 0x79, 0xcf, 0x2c, 0x13, 0x3c, 0x2c, 0xc7, 0x3b, 0xd1, 0xb9, 0x61, 0xcf, 0x05, 0x0c, 0x05, 0x15, 0x1f, 0x0e, 0xdd, 0xfc, 0xc3, 0x69, 0x72, 0x85, 0xfb, 0x9a, 0x7a, 0x6e, 0xa1, 0xa7, 0x55, 0xf6, 0xe0, 0xae, 0x25, 0x38, 0x36, 0x09, 0x72, 0xf3, 0xe0, 0xc3, 0x1d, 0x87, 0x77, 0x62, 0x19, 0x37, 0x7f, 0x2c, 0x16, 0x52, 0xed, 0x38, 0x8e, 0x29, 0xdb, 0xa7, 0x99, 0x97, 0x11, 0x93, 0x46, 0xac, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x1c, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xd9, 0xc3, 0x96, 0x4f, 0x97, 0x39, 0xa4, 0x89, 0xae, 0xc8, 0x3b, 0x9d, 0x91, 0xe0, 0x49, 0x13, 0x48, 0xdd, 0xc3, 0x49, 0x6a, 0xea, 0xed, 0x7d, 0x36, 0xcc, 0x80, 0xb4, 0xd3, 0xdf, 0x73, 0x45, 0x5c, 0x30, 0xe2, 0x6a, 0xd3, 0x20, 0x9a, 0xf4, 0xfb, 0x15, 0x94, 0xa0, 0x42, 0x52, 0x54, 0xb9, 0x6c, 0x1d, 0x9b, 0xef, 0x30, 0x1b, 0x3e, 0x14, 0x4f, 0x56, 0x01, 0x9a, 0xfe, 0xf5, 0x4f, 0xbe, 0xac, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x1d, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xb9, 0x0e, 0x7f, 0x5b, 0x11, 0x47, 0xbc, 0x7a, 0xce, 0xc7, 0x27, 0x3f, 0x9a, 0x25, 0x7d, 0xce, 0x32, 0x1f, 0x9d, 0x6c, 0xf5, 0x85, 0xf6, 0x51, 0x55, 0xe6, 0xc5, 0x92, 0x90, 0xe6, 0x24, 0x7f, 0x65, 0xb6, 0xad, 0xb2, 0xf6, 0xb7, 0xd6, 0x6e, 0x93, 0x02, 0xa3, 0x7f, 0x0b, 0xec, 0xd2, 0xcf, 0xc3, 0xdb, 0x5e, 0xaf, 0xdc, 0x28, 0x00, 0x85, 0xb0, 0x8a, 0x1d, 0x08, 0x7f, 0x55, 0x81, 0x09, 0xac, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x04, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x1e, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xb2, 0x2d, 0x48, 0x7d, 0xd4, 0x91, 0xc2, 0x9e, 0x60, 0xfc, 0x3e, 0x8b, 0xa3, 0xdd, 0x95, 0x9c, 0x5f, 0xf0, 0x58, 0x48, 0xa2, 0xaf, 0x26, 0x9a, 0x00, 0x9a, 0x68, 0x3c, 0x1c, 0x22, 0xc5, 0x61, 0x8e, 0xb6, 0x31, 0xe4, 0x2b, 0xa0, 0x3c, 0x2e, 0x5b, 0x37, 0xd6, 0x23, 0xa4, 0xc1, 0xc3, 0x27, 0x71, 0xa7, 0xa3, 0xb6, 0x03, 0x03, 0x17, 0x67, 0x00, 0x2f, 0x9c, 0x4c, 0x84, 0x3f, 0x1c, 0xf9, 0xac, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x1f, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x34, 0x68, 0x5f, 0xbc, 0x27, 0xde, 0xe9, 0xdd, 0xf7, 0x61, 0x06, 0xdd, 0x35, 0x1e, 0xcf, 0x20, 0xa8, 0x9c, 0x53, 0x6d, 0x02, 0x0a, 0xe5, 0xb8, 0x16, 0x4e, 0x53, 0xb1, 0xde, 0x2e, 0xef, 0x03, 0xa9, 0xc2, 0xbd, 0xe7, 0x9a, 0xea, 0x65, 0x56, 0xb7, 0xff, 0x42, 0xc0, 0xdb, 0x3e, 0xe6, 0x3b, 0x15, 0xb1, 0x9f, 0x03, 0x65, 0x78, 0xa4, 0x0b, 0xe5, 0xe2, 0x9a, 0x4e, 0x56, 0x3d, 0xc9, 0x49, 0xad, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x20, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x96, 0x9d, 0x68, 0x01, 0x10, 0x0c, 0x0c, 0xff, 0x27, 0x95, 0x7f, 0x00, 0x3d, 0x59, 0x94, 0xbb, 0x6f, 0xc3, 0xe8, 0x05, 0x37, 0x27, 0x34, 0x12, 0xc2, 0x37, 0x5c, 0xbc, 0x59, 0xed, 0xfb, 0x14, 0x62, 0xde, 0xf5, 0x0a, 0xb4, 0x7b, 0x73, 0xe0, 0x41, 0x89, 0xb9, 0x31, 0x4b, 0x32, 0xf1, 0x8b, 0x23, 0xc2, 0x13, 0x63, 0xbb, 0xb1, 0x70, 0x0b, 0xde, 0x5d, 0x6f, 0x2d, 0xa8, 0xd7, 0xda, 0xc7, 0xad, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x60, 0x12, 0x1e, 0x48, 0x0f, 0x5e, 0x68, 0x74, 0x0e, 0x4a, 0xd5, 0xe3, 0x5e, 0x43, 0xa9, 0xaf, 0x8f, 0x3e, 0xb9, 0x09, 0xdf, 0xe7, 0xa8, 0x0b, 0x86, 0x1a, 0xf0, 0x47, 0xf3, 0xcf, 0x29, 0x31, 0xc4, 0x6f, 0xdb, 0xbf, 0x4a, 0x98, 0x11, 0x81, 0x3d, 0x7e, 0xf6, 0x6c, 0xa7, 0x0a, 0x89, 0xa9, 0x3f, 0x37, 0x7a, 0xec, 0x9e, 0x42, 0xf8, 0xc7, 0xbd, 0x13, 0xd2, 0x0d, 0xc4, 0x2e, 0xf4, 0xe6, 0xad, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x22, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x9a, 0xa0, 0x05, 0x70, 0x0a, 0x68, 0xcc, 0xfd, 0xfc, 0x15, 0x8c, 0x9b, 0xe0, 0xd6, 0x2b, 0x0e, 0xbd, 0x75, 0x76, 0x34, 0x40, 0x7c, 0x24, 0x80, 0xc9, 0x05, 0x75, 0x8f, 0x80, 0x3c, 0xf9, 0x53, 0x92, 0xdf, 0x59, 0xab, 0x81, 0x1f, 0x3f, 0x6a, 0x5b, 0x3b, 0x2f, 0xd5, 0x08, 0xb1, 0x50, 0x29, 0x97, 0x1c, 0xba, 0x8c, 0x76, 0xab, 0x5a, 0xad, 0xd2, 0x15, 0xba, 0xee, 0x41, 0xc1, 0xad, 0x56, 0xad, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x23, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x11, 0xd5, 0xaa, 0x61, 0x37, 0xf4, 0x8a, 0xa4, 0xa2, 0xd0, 0x29, 0xbe, 0xed, 0x93, 0x9a, 0xfc, 0xed, 0x99, 0xef, 0x19, 0xab, 0x01, 0xbf, 0x0a, 0xea, 0xb4, 0xd8, 0x8b, 0x99, 0x9c, 0xfa, 0x51, 0x3d, 0xaa, 0x30, 0xf8, 0x57, 0xb9, 0x9d, 0xeb, 0x57, 0x00, 0x9b, 0x0a, 0x2c, 0xf5, 0xd3, 0x71, 0x80, 0xda, 0xe0, 0x65, 0x71, 0xb8, 0xd9, 0x7d, 0xeb, 0x38, 0x77, 0xf4, 0xe4, 0xb4, 0x88, 0xd1, 0xad, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x24, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x59, 0x6c, 0xea, 0xdc, 0xb7, 0x69, 0xb0, 0x5d, 0x2b, 0x7f, 0xca, 0x9d, 0xee, 0x99, 0x7d, 0xa1, 0xa3, 0x29, 0x52, 0xc0, 0x60, 0x1a, 0x78, 0x7c, 0xb8, 0xe2, 0x3f, 0x2d, 0x33, 0x11, 0x97, 0x6f, 0xff, 0x76, 0x1a, 0xf1, 0xa0, 0x91, 0x18, 0x27, 0xc1, 0xfe, 0xe0, 0xc6, 0x38, 0xf4, 0x67, 0x5b, 0x54, 0x14, 0x6a, 0x3f, 0x17, 0xad, 0x65, 0xf3, 0x22, 0x8b, 0x63, 0x28, 0xa5, 0x9e, 0x57, 0x2a, 0xad, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x25, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xca, 0xc0, 0x01, 0xeb, 0x2c, 0x15, 0xd3, 0x86, 0x71, 0x46, 0x85, 0x8d, 0x9b, 0x62, 0x07, 0x35, 0xc9, 0x94, 0x34, 0x30, 0xc9, 0x66, 0xff, 0x7b, 0x43, 0xba, 0xd9, 0x1e, 0x7f, 0x45, 0xb5, 0x09, 0x42, 0x0b, 0xac, 0x97, 0x2f, 0x12, 0x88, 0xb1, 0x90, 0x11, 0x7f, 0x81, 0x5d, 0xe3, 0x18, 0xc3, 0x05, 0xb4, 0x88, 0x2e, 0x7b, 0xc8, 0xe0, 0x0c, 0x38, 0x06, 0xb4, 0x56, 0xd7, 0xbc, 0x97, 0x06, 0xae, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x26, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x5f, 0xf8, 0x5b, 0xa1, 0xa9, 0xbc, 0xa6, 0x1e, 0xba, 0xa8, 0x9e, 0x99, 0x12, 0x6a, 0x41, 0xc9, 0x76, 0xce, 0x90, 0x24, 0xc9, 0xc6, 0xea, 0x0c, 0x1d, 0x97, 0xfc, 0xcb, 0x5e, 0xcb, 0xcd, 0x48, 0xe4, 0xff, 0x00, 0x34, 0x14, 0xa8, 0x81, 0x79, 0xbe, 0xcf, 0x0d, 0xae, 0xfd, 0x05, 0x65, 0xb6, 0x64, 0x8d, 0xa3, 0xfa, 0x8b, 0x1e, 0x98, 0x62, 0xfb, 0x72, 0x54, 0xd6, 0xcb, 0xc9, 0x2b, 0x43, 0xae, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x27, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xd3, 0xe4, 0xf3, 0x32, 0x5a, 0x79, 0x9d, 0x70, 0xe4, 0x69, 0xc4, 0x18, 0xe7, 0xfc, 0xe0, 0xf3, 0x25, 0xc5, 0x2b, 0xe2, 0xee, 0x1c, 0x19, 0x0b, 0x84, 0xff, 0x5b, 0x39, 0xd5, 0x67, 0xdd, 0x2c, 0x4d, 0x34, 0xd1, 0x2f, 0x29, 0x80, 0x26, 0xa2, 0x75, 0xef, 0x66, 0xfa, 0xf0, 0x5c, 0x08, 0x3d, 0x36, 0x20, 0x02, 0x08, 0xe0, 0x6e, 0xf3, 0x9d, 0xf4, 0xde, 0x88, 0xfa, 0xaf, 0x51, 0xa8, 0xa0, 0xae, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x28, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x05, 0xe0, 0x36, 0x42, 0x63, 0xbb, 0x17, 0xcb, 0x11, 0x2c, 0x7a, 0x6b, 0x49, 0x80, 0x7a, 0xbc, 0x56, 0x76, 0x6c, 0xa9, 0xf3, 0x3f, 0xce, 0x8e, 0x4d, 0x4e, 0x1a, 0x87, 0xd2, 0x49, 0x75, 0x18, 0x81, 0x4a, 0xa8, 0x3f, 0xb0, 0xc6, 0x5f, 0x97, 0x5b, 0x27, 0x3b, 0x20, 0xc3, 0x28, 0x3d, 0xfd, 0x5d, 0x0d, 0x92, 0xe0, 0xd7, 0x44, 0x62, 0x7e, 0x70, 0xe8, 0x16, 0x69, 0x37, 0x04, 0xb4, 0x52, 0xae, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x29, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x9d, 0xe0, 0x11, 0x63, 0x00, 0xca, 0xca, 0x13, 0x92, 0xcc, 0xb3, 0xaf, 0xdb, 0xe2, 0x2c, 0x0b, 0xa4, 0x03, 0x79, 0x5c, 0x7e, 0x68, 0xd2, 0x9b, 0x0e, 0x03, 0x2a, 0xc7, 0x20, 0xd7, 0x2b, 0x32, 0x21, 0x60, 0x70, 0x2e, 0x16, 0x2e, 0xdb, 0x0d, 0xa7, 0xf5, 0x35, 0xd4, 0x6f, 0xc0, 0xe6, 0x08, 0x87, 0x9a, 0x1b, 0x6d, 0x8a, 0x37, 0x84, 0xf1, 0x83, 0x32, 0xc7, 0xaa, 0x7b, 0xad, 0x2e, 0x9d, 0xae, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x2a, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x35, 0x42, 0x03, 0x43, 0xac, 0x81, 0x9c, 0x9d, 0x40, 0xe6, 0xe0, 0xbd, 0x55, 0x95, 0x76, 0x37, 0xae, 0xd4, 0x04, 0xfa, 0x2e, 0xd2, 0x36, 0xf7, 0x8b, 0x1d, 0x4b, 0x61, 0xfb, 0x27, 0x76, 0x02, 0xe4, 0x0e, 0xe1, 0xa3, 0xa4, 0xf5, 0x76, 0x4d, 0x49, 0xf9, 0xb3, 0x52, 0xa2, 0xe1, 0x81, 0xeb, 0xe4, 0xae, 0x76, 0x7e, 0x00, 0x58, 0xd3, 0x8f, 0xde, 0xba, 0xf8, 0x8e, 0x7d, 0xa4, 0xe9, 0xe1, 0xae, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x04, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x2b, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xec, 0x89, 0xaf, 0xed, 0x1c, 0x02, 0xee, 0x80, 0xc9, 0x00, 0x4d, 0xe7, 0x15, 0xb1, 0xa1, 0x39, 0x44, 0x74, 0xa1, 0x22, 0xb3, 0x27, 0x77, 0x0b, 0x00, 0x0d, 0xcb, 0x7c, 0x29, 0xb7, 0x28, 0x2f, 0x1b, 0xa3, 0x6b, 0x2e, 0x07, 0x80, 0xbd, 0x43, 0x22, 0x56, 0x98, 0x62, 0x2c, 0x3c, 0x48, 0xa9, 0xab, 0x99, 0xde, 0xc7, 0x94, 0x45, 0xd3, 0xe7, 0xbc, 0x8d, 0x5a, 0xe8, 0x13, 0x35, 0x76, 0xeb, 0xaf, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x2c, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xd5, 0xd5, 0xff, 0x85, 0x51, 0x56, 0x5d, 0x22, 0x17, 0xe6, 0xf2, 0x0d, 0x0e, 0xac, 0xe6, 0x7c, 0xe5, 0x03, 0x37, 0xb4, 0x2f, 0x71, 0x68, 0xbc, 0xac, 0x7e, 0x87, 0xd4, 0x15, 0x6b, 0x24, 0x46, 0xcd, 0x3d, 0x8d, 0x5d, 0x7f, 0xf9, 0x30, 0xc8, 0x4a, 0x26, 0xe6, 0x85, 0xb9, 0x9c, 0x22, 0xc6, 0x0e, 0x5a, 0x0b, 0xbe, 0x57, 0x00, 0x1b, 0x01, 0xe9, 0xb4, 0xa2, 0xa6, 0x96, 0x48, 0x0a, 0x3b, 0xaf, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x2d, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xd9, 0xec, 0x63, 0x48, 0xab, 0x3f, 0x33, 0xd8, 0xbb, 0x73, 0x50, 0x63, 0x26, 0xda, 0x55, 0x98, 0x02, 0xab, 0x47, 0x74, 0x37, 0x42, 0x2a, 0x00, 0xb3, 0xa1, 0x19, 0x9b, 0x50, 0x4b, 0xc5, 0x5b, 0xf5, 0x42, 0x5b, 0x45, 0xc0, 0x02, 0x6f, 0xec, 0x9c, 0x3e, 0x2e, 0x16, 0xe8, 0x00, 0xaa, 0x75, 0xa2, 0x20, 0xa2, 0x78, 0x48, 0xc3, 0x73, 0xac, 0xe3, 0xc2, 0x0a, 0x18, 0xa3, 0x4f, 0xea, 0x52, 0xaf, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x2e, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xc5, 0xe4, 0xba, 0xf7, 0xaa, 0x27, 0xa6, 0xd5, 0x14, 0x70, 0x63, 0xeb, 0xcc, 0xb7, 0x7e, 0x38, 0x1b, 0x0a, 0x16, 0x93, 0x9d, 0x79, 0x82, 0x50, 0x77, 0x01, 0xd3, 0xa3, 0xb3, 0xe8, 0x8b, 0x1e, 0xa7, 0x66, 0x01, 0x19, 0xcb, 0x01, 0x23, 0x85, 0x04, 0x85, 0x0c, 0x25, 0x28, 0xb3, 0xb3, 0x71, 0xcd, 0x1f, 0x58, 0x95, 0xda, 0x5e, 0x62, 0x0f, 0xc0, 0xa0, 0x44, 0x83, 0x62, 0x57, 0xbf, 0x64, 0xaf, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x2f, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x09, 0x25, 0x44, 0x06, 0xac, 0x2f, 0x10, 0x28, 0xea, 0x8e, 0xb2, 0x69, 0x3b, 0x2c, 0xdb, 0x1f, 0xea, 0x04, 0x7c, 0xb3, 0x49, 0xd7, 0xb2, 0x70, 0xb9, 0x1e, 0xad, 0x7a, 0xf5, 0x01, 0x4e, 0x04, 0xb7, 0x1f, 0xdc, 0xf9, 0x15, 0x2e, 0x76, 0xb7, 0x6c, 0x18, 0x08, 0x87, 0x7d, 0xf7, 0xbb, 0x8e, 0x37, 0x95, 0x36, 0xd4, 0x6a, 0x28, 0x9f, 0xbc, 0xe9, 0xa9, 0x9b, 0x20, 0x1f, 0xd6, 0x18, 0x68, 0xaf, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x06, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x30, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xd1, 0x7e, 0xb5, 0x0e, 0xd9, 0x77, 0xc2, 0x72, 0x29, 0x57, 0x8a, 0x93, 0x83, 0x13, 0xb3, 0xd8, 0x66, 0x79, 0x66, 0x81, 0x81, 0xa4, 0xe0, 0x17, 0x32, 0xcb, 0x52, 0xf9, 0x5c, 0x11, 0x65, 0x08, 0xf7, 0x55, 0x80, 0x9a, 0xaf, 0x68, 0x1a, 0x5c, 0x0f, 0x78, 0x39, 0xf6, 0x58, 0x13, 0xaa, 0x6f, 0xc1, 0x71, 0xb2, 0xe5, 0xdc, 0xd8, 0x7f, 0x35, 0xb1, 0x3b, 0x49, 0xb5, 0x63, 0x90, 0x16, 0xae, 0xaf, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x31, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x10, 0x0d, 0x4b, 0xdd, 0xa8, 0xd6, 0x18, 0x75, 0x37, 0xd8, 0x8e, 0x81, 0x0c, 0xe2, 0xaa, 0xdf, 0x58, 0x18, 0x02, 0x77, 0x5b, 0xb7, 0x4a, 0x9a, 0xce, 0xcb, 0x69, 0x58, 0xc7, 0x5d, 0xe5, 0x25, 0x1f, 0x5b, 0x24, 0xd5, 0x7f, 0xc1, 0x9c, 0x7f, 0x73, 0x45, 0x1a, 0x55, 0x9f, 0x07, 0x58, 0x18, 0x8a, 0xf4, 0xab, 0x7b, 0xe7, 0x2e, 0xcb, 0x22, 0x99, 0x6b, 0xe0, 0x22, 0x5b, 0x0f, 0xb0, 0x99, 0xb0, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x32, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xc3, 0x33, 0x30, 0x13, 0xd4, 0x9f, 0x64, 0x6c, 0x18, 0x53, 0x71, 0x54, 0x84, 0x4d, 0x37, 0xf8, 0x18, 0x71, 0x44, 0x4b, 0x3f, 0xce, 0x3a, 0x68, 0xf6, 0xe1, 0x65, 0xd7, 0x09, 0x55, 0x46, 0x11, 0x59, 0x37, 0xb9, 0x0e, 0xd7, 0x26, 0x37, 0x58, 0x8e, 0x41, 0x84, 0x94, 0x24, 0x69, 0xa3, 0xca, 0x1b, 0xf1, 0x83, 0xfa, 0x65, 0xb9, 0xc2, 0x78, 0x5b, 0x45, 0x92, 0xea, 0x60, 0x9c, 0x8b, 0x59, 0xb0, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x33, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x17, 0xe2, 0x41, 0x07, 0x7f, 0x8c, 0xd6, 0x18, 0x73, 0x45, 0x03, 0xd6, 0x6c, 0x0c, 0xe8, 0x28, 0xb7, 0xd1, 0xad, 0xd6, 0x01, 0x90, 0x31, 0x60, 0xa3, 0xae, 0x15, 0x31, 0xb8, 0xea, 0x1e, 0x4c, 0xe6, 0x9c, 0x66, 0xd6, 0x45, 0x63, 0x65, 0x72, 0x24, 0x54, 0x8f, 0x7e, 0xcf, 0xd7, 0xed, 0x35, 0x71, 0xfd, 0x5f, 0x69, 0x76, 0x20, 0x5e, 0xc8, 0x06, 0xd7, 0x2f, 0x9a, 0xad, 0x95, 0xd3, 0x52, 0xb0, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x34, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xfa, 0x40, 0xc6, 0xe3, 0xa1, 0x5a, 0x65, 0x9e, 0xf5, 0x82, 0xad, 0x24, 0xf4, 0xa2, 0xc0, 0xa1, 0xc8, 0x01, 0x97, 0x8d, 0xa4, 0xb5, 0x73, 0xa5, 0x28, 0xbf, 0xb0, 0xfb, 0x73, 0xc3, 0xcf, 0x12, 0x17, 0x96, 0x63, 0x1d, 0x47, 0x9c, 0x9f, 0xa6, 0xf6, 0xbc, 0xc0, 0xc5, 0xc1, 0xf0, 0xcc, 0x91, 0xe1, 0x0e, 0xbb, 0x56, 0xe3, 0xb6, 0xc2, 0xb8, 0x67, 0xc0, 0x05, 0x2d, 0x09, 0x24, 0x43, 0x2c, 0xb0, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x35, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xb3, 0x56, 0xe0, 0xe5, 0xbc, 0xd4, 0xf6, 0x45, 0x4e, 0xd9, 0xe6, 0xf1, 0xad, 0xf9, 0x1b, 0x46, 0x67, 0x23, 0xb4, 0x59, 0x63, 0xb0, 0x2d, 0xce, 0xcf, 0x2e, 0x89, 0xc0, 0xd1, 0x04, 0x5a, 0x24, 0xd4, 0x53, 0xcc, 0x47, 0x6a, 0x56, 0x62, 0x96, 0x4c, 0xe6, 0xee, 0xcd, 0xdb, 0x78, 0xef, 0xb4, 0x0e, 0x16, 0x16, 0x22, 0x3d, 0x4c, 0x7f, 0xd5, 0x4f, 0x6c, 0xa8, 0x4a, 0xbd, 0xc8, 0x7e, 0x02, 0xb0, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x36, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xad, 0x91, 0xfd, 0x99, 0xff, 0x63, 0x9b, 0x89, 0xaf, 0x58, 0x5c, 0x3b, 0x87, 0x08, 0x06, 0x2a, 0x48, 0xad, 0x19, 0x66, 0x04, 0x00, 0xd2, 0x04, 0xef, 0x09, 0x9c, 0x2d, 0x66, 0xd1, 0xca, 0x57, 0xb0, 0x34, 0x9e, 0xb1, 0xa1, 0x61, 0xd0, 0x4f, 0xc8, 0x22, 0x2c, 0xfb, 0xc0, 0x2b, 0x8a, 0x1a, 0xb9, 0x64, 0xab, 0xc5, 0x74, 0x4f, 0x2c, 0xd7, 0x26, 0xb8, 0xba, 0xae, 0xf1, 0xab, 0xcc, 0x4d, 0xb0, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x37, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xba, 0xcb, 0x69, 0xed, 0x2f, 0x63, 0xb3, 0x8d, 0xd1, 0x03, 0x11, 0x4b, 0xbc, 0x24, 0xdd, 0x9b, 0x60, 0x9f, 0x8b, 0x63, 0x80, 0xf1, 0xf3, 0x62, 0xa0, 0x5c, 0x3f, 0x85, 0xf9, 0xe6, 0xcf, 0x10, 0x2a, 0x39, 0x19, 0x05, 0xe0, 0x06, 0xfc, 0xba, 0x72, 0x3d, 0x56, 0xc6, 0xa3, 0xeb, 0x27, 0xef, 0xa4, 0x39, 0x6e, 0xde, 0x18, 0xf9, 0xc5, 0x0e, 0x0b, 0xe9, 0x0d, 0xc1, 0xe9, 0x28, 0xf1, 0x63, 0xb1, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x05, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x38, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x24, 0x88, 0x95, 0x01, 0xa0, 0xda, 0x6f, 0xfd, 0x4e, 0x62, 0x52, 0xfd, 0x87, 0x46, 0x4b, 0x9e, 0xb5, 0x4d, 0xbf, 0x7b, 0x1c, 0x75, 0x9c, 0x2a, 0xd1, 0x54, 0x15, 0x2c, 0x3d, 0x7c, 0x5b, 0x2e, 0x8c, 0x36, 0x26, 0xfb, 0x53, 0x89, 0x21, 0xb3, 0xf5, 0x97, 0x86, 0xde, 0x9e, 0x6c, 0xa2, 0x48, 0x7b, 0x3a, 0x1f, 0x5c, 0x80, 0xa3, 0xd9, 0xdd, 0x82, 0xc2, 0x7a, 0x6b, 0x1a, 0x6e, 0xac, 0x5a, 0xb1, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x39, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x90, 0xea, 0x4e, 0xd8, 0xd0, 0xf7, 0xb2, 0x30, 0xfd, 0x2e, 0xfa, 0x6b, 0x5f, 0xfb, 0x07, 0xe5, 0xee, 0x1e, 0xfd, 0x59, 0x75, 0x4e, 0x79, 0x00, 0xff, 0x4e, 0x24, 0xf7, 0x93, 0xc2, 0xd9, 0x26, 0xf8, 0x48, 0x1e, 0x6e, 0x63, 0xa7, 0x95, 0xf6, 0x46, 0xf1, 0xd0, 0x6c, 0xac, 0xdd, 0x2d, 0x2c, 0xe7, 0xb1, 0x76, 0xaf, 0xa5, 0x89, 0x33, 0x7e, 0x86, 0x9c, 0x55, 0xe8, 0x64, 0xdf, 0xec, 0x56, 0xb1, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x3a, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x79, 0xf7, 0x69, 0x72, 0xc3, 0x86, 0xa4, 0x5c, 0xbd, 0x62, 0xd5, 0xcd, 0x1f, 0x57, 0x7e, 0x36, 0xb2, 0xd3, 0x78, 0x95, 0xea, 0x48, 0xad, 0x4f, 0x25, 0xb2, 0xaa, 0x6c, 0x38, 0x6e, 0x48, 0x34, 0x04, 0xdf, 0xb6, 0x8e, 0x4e, 0x8a, 0x17, 0x16, 0xe1, 0x51, 0xc7, 0x02, 0x8c, 0x8c, 0x0e, 0xa9, 0xe8, 0x0e, 0x98, 0x71, 0xc3, 0xd7, 0xf2, 0xe1, 0xf2, 0x2b, 0x3a, 0x3d, 0x71, 0x9f, 0xb2, 0xa5, 0xb1, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x3b, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x3e, 0x5f, 0xb2, 0x30, 0x77, 0xce, 0x93, 0xfb, 0x14, 0x12, 0xfe, 0xb5, 0x3b, 0x3c, 0x6c, 0xed, 0xec, 0xfe, 0xa1, 0x2e, 0xdf, 0x96, 0xae, 0xa0, 0x2a, 0x2f, 0xde, 0xc6, 0x83, 0x56, 0x47, 0x50, 0x41, 0x9f, 0xf4, 0x0c, 0x0a, 0xf3, 0xe1, 0xf9, 0xbd, 0x99, 0x2e, 0xdf, 0x37, 0x11, 0x8f, 0x70, 0x9a, 0xbc, 0x77, 0x04, 0x58, 0xbb, 0x5f, 0x73, 0xe6, 0x4a, 0x90, 0x68, 0xdd, 0x6a, 0xa2, 0x85, 0xb1, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x3c, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x1d, 0x51, 0x7a, 0x82, 0xa9, 0xae, 0x83, 0x66, 0x0d, 0x8c, 0x57, 0xae, 0xef, 0xb1, 0x4b, 0x57, 0xef, 0xaf, 0x3b, 0x93, 0xb2, 0x2b, 0x43, 0x73, 0x55, 0x97, 0xbd, 0x21, 0x6a, 0xf6, 0x6b, 0x16, 0x1e, 0xf1, 0x25, 0xe5, 0xeb, 0x8b, 0xaa, 0x3a, 0xd7, 0x1c, 0x63, 0x64, 0xe0, 0xb9, 0xfe, 0x07, 0x8e, 0x29, 0xf1, 0xb3, 0x90, 0x91, 0xc4, 0x78, 0xab, 0xcc, 0xc0, 0x59, 0x44, 0xbf, 0x43, 0xfc, 0xb1, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x3d, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x1c, 0xf4, 0xa4, 0xd8, 0x75, 0x52, 0x5b, 0xe8, 0x5e, 0xd6, 0x4b, 0xe8, 0x20, 0x0b, 0x41, 0x49, 0xba, 0x22, 0x46, 0x52, 0xf8, 0x80, 0xf0, 0x50, 0xf1, 0x55, 0xe3, 0xdd, 0x0f, 0x6d, 0xcd, 0x2d, 0x17, 0x0c, 0x26, 0xd3, 0x02, 0x63, 0x76, 0x0e, 0x6a, 0xd9, 0xaa, 0x81, 0x94, 0xf9, 0xea, 0x69, 0x95, 0x75, 0x5a, 0x57, 0xe0, 0x59, 0x60, 0x10, 0xfa, 0xac, 0x24, 0x4c, 0x63, 0x31, 0x5c, 0x3c, 0xb2, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x3e, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xfc, 0xa7, 0xee, 0xe1, 0x1c, 0xd5, 0x59, 0x53, 0xe4, 0x41, 0x51, 0x44, 0x8a, 0x37, 0x79, 0x37, 0x46, 0xc0, 0x5a, 0xce, 0x49, 0xd1, 0x28, 0x1b, 0xb6, 0xf2, 0x77, 0x72, 0xed, 0x63, 0x8b, 0x2b, 0x67, 0xf5, 0x44, 0x6d, 0x20, 0x67, 0xd3, 0x94, 0xab, 0x55, 0xd0, 0xe7, 0x8e, 0x65, 0x03, 0xe0, 0xdf, 0x4d, 0xa7, 0x13, 0x7a, 0x91, 0x0a, 0x4c, 0x06, 0x69, 0x07, 0x50, 0x15, 0x6c, 0xef, 0x79, 0xb2, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x3f, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x11, 0xad, 0x84, 0x55, 0x46, 0xac, 0x70, 0x97, 0x06, 0x71, 0x6e, 0xa3, 0x09, 0xea, 0x4b, 0x5d, 0xc0, 0x58, 0xcd, 0x1b, 0xe3, 0x47, 0xdb, 0x51, 0x7f, 0x1a, 0xe8, 0xae, 0x50, 0xc9, 0x36, 0x19, 0x43, 0xaa, 0x4f, 0xa2, 0x1f, 0xe9, 0xf6, 0x4d, 0x97, 0xe0, 0xed, 0x3d, 0x93, 0x89, 0x43, 0x39, 0xeb, 0x6a, 0x84, 0xe8, 0x34, 0xad, 0x7e, 0x07, 0x50, 0x33, 0x70, 0x7b, 0x15, 0xa0, 0x9b, 0x42, 0xb2, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x40, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xe7, 0x8a, 0xa3, 0x45, 0x2c, 0xf4, 0x00, 0x7a, 0xde, 0x84, 0x71, 0x0d, 0x76, 0x14, 0x45, 0x53, 0x4b, 0x02, 0x46, 0xb2, 0xc3, 0xb5, 0xb0, 0x0c, 0xb8, 0x88, 0x11, 0xe0, 0x01, 0xb2, 0x2e, 0x06, 0x71, 0xdc, 0x09, 0xc2, 0x6f, 0xa4, 0xf6, 0xe1, 0x19, 0xdc, 0xd7, 0x2c, 0x5c, 0x20, 0x12, 0x6f, 0x23, 0x65, 0xa7, 0x5d, 0xfa, 0xb9, 0x68, 0x9a, 0xa1, 0xb6, 0x7e, 0x4a, 0x95, 0xa1, 0x9a, 0xd0, 0xb2, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x41, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x3f, 0xd3, 0x3c, 0x4e, 0xcd, 0x96, 0x8f, 0x1c, 0x46, 0x10, 0xe6, 0xf6, 0xf6, 0x0e, 0x7c, 0x0f, 0x1a, 0xf8, 0x38, 0x75, 0x2b, 0xa5, 0x36, 0x6e, 0xd3, 0x25, 0x10, 0xcb, 0x26, 0xb3, 0x04, 0x3c, 0x14, 0xad, 0x22, 0xa3, 0x59, 0x1f, 0x48, 0x18, 0x2e, 0xe7, 0x4f, 0x23, 0xa1, 0x75, 0x0f, 0x13, 0x7b, 0x13, 0x5c, 0xb9, 0x47, 0x5f, 0xb2, 0x01, 0x09, 0x8f, 0x2b, 0xb4, 0xc2, 0xf1, 0xfd, 0xd9, 0xb2, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x42, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xd6, 0xa3, 0x97, 0x93, 0xd3, 0x1c, 0xbf, 0xd1, 0xaf, 0x6b, 0x33, 0x55, 0x2d, 0x9b, 0xc2, 0xd5, 0xe0, 0x81, 0x58, 0x77, 0x41, 0x9b, 0x6d, 0x86, 0x0a, 0x68, 0x93, 0xb1, 0xeb, 0xb1, 0xc4, 0x21, 0x2b, 0xed, 0xb1, 0x44, 0xbd, 0x37, 0x8f, 0xd4, 0xe5, 0xd3, 0xb8, 0xc0, 0xbe, 0x92, 0xaa, 0xe4, 0xe9, 0x5d, 0x8e, 0xc8, 0x61, 0x8c, 0x2f, 0xa5, 0xb1, 0xdd, 0x91, 0x2d, 0x8c, 0x1d, 0x55, 0xe0, 0xb2, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x43, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xaf, 0xdc, 0xdd, 0x52, 0xd9, 0xeb, 0x6d, 0xe8, 0xcd, 0x06, 0x2f, 0xda, 0x1c, 0x94, 0x21, 0x47, 0x9e, 0xda, 0xd8, 0x71, 0xae, 0x7c, 0x27, 0xb9, 0x9c, 0x48, 0xee, 0x58, 0x9e, 0x13, 0x43, 0x1a, 0x10, 0x4b, 0x8c, 0x78, 0xe7, 0x24, 0x62, 0xda, 0x96, 0xc7, 0xf3, 0x9a, 0xba, 0x43, 0xf8, 0x90, 0xa8, 0x65, 0x30, 0xd4, 0xfb, 0x56, 0xae, 0xe3, 0xd9, 0x6c, 0x99, 0xc2, 0x42, 0xd5, 0x24, 0xc0, 0xb3, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x44, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xb6, 0x3b, 0x5f, 0xbe, 0xe3, 0xb8, 0x5e, 0x33, 0x87, 0x3d, 0x93, 0xdc, 0xbf, 0x1d, 0x56, 0x6c, 0x90, 0x81, 0xd4, 0xa6, 0x3c, 0x6e, 0xca, 0x84, 0xfc, 0x96, 0xbb, 0xa1, 0xc8, 0x62, 0x52, 0x0b, 0x64, 0x93, 0x4c, 0xd7, 0x1d, 0x23, 0xa2, 0x2f, 0x62, 0xb2, 0x49, 0x6b, 0xea, 0x8c, 0x64, 0xf0, 0x64, 0xc4, 0x93, 0x1a, 0x6e, 0xf4, 0xb9, 0x38, 0x4b, 0x4a, 0x50, 0x90, 0xb8, 0xe2, 0x76, 0x12, 0xb3, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x45, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x1a, 0x2c, 0x83, 0xdb, 0xa9, 0x83, 0x4c, 0x76, 0x99, 0x7b, 0x89, 0xf4, 0x77, 0xb3, 0x45, 0xa4, 0x7a, 0x96, 0x00, 0xcb, 0xf3, 0x0b, 0xed, 0xcf, 0x4b, 0x38, 0x0a, 0x0a, 0x11, 0xbc, 0x81, 0x32, 0xb6, 0xf5, 0xe5, 0x4d, 0x82, 0xcc, 0xd8, 0x8e, 0x8b, 0xc1, 0xdc, 0x11, 0x24, 0xe4, 0x2e, 0xc2, 0xf2, 0xb1, 0xd9, 0x43, 0x57, 0x2d, 0x7f, 0x71, 0x9c, 0x55, 0xea, 0x48, 0xd5, 0x80, 0x58, 0x41, 0xb3, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x46, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x56, 0x74, 0x83, 0xe2, 0xc2, 0xf0, 0x91, 0xaf, 0x7c, 0xd7, 0x1d, 0x03, 0xaa, 0xfb, 0x7b, 0x85, 0xc5, 0x03, 0x25, 0x16, 0xed, 0x83, 0x18, 0xad, 0x97, 0x0e, 0x4d, 0xb3, 0x24, 0x85, 0x3b, 0x34, 0x4c, 0xec, 0x6b, 0xad, 0xa6, 0x93, 0x60, 0x0b, 0x65, 0x5c, 0xf4, 0xff, 0xca, 0xee, 0x0d, 0x2d, 0xf3, 0x5f, 0x78, 0x09, 0xed, 0x99, 0x58, 0xda, 0x83, 0x45, 0x78, 0x3b, 0x52, 0xa0, 0xd4, 0x59, 0xb3, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x47, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x34, 0xb1, 0x6f, 0x26, 0x6d, 0xee, 0x68, 0x22, 0x39, 0x83, 0x1d, 0xc6, 0x10, 0xd0, 0x3d, 0x10, 0x97, 0x4d, 0x8a, 0xd4, 0x00, 0xa4, 0x1f, 0xea, 0xd6, 0xbe, 0x3d, 0x03, 0xb9, 0x4a, 0xcb, 0x7c, 0xfd, 0xf2, 0x01, 0xcf, 0x64, 0xbc, 0x36, 0x31, 0xfb, 0x44, 0xb4, 0x61, 0x8c, 0xb6, 0x72, 0x0b, 0xc1, 0x51, 0x2f, 0x6a, 0x43, 0xeb, 0x41, 0x4c, 0x5b, 0x11, 0x58, 0xe0, 0xe8, 0x50, 0x55, 0x28, 0xb3, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x48, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x96, 0x97, 0x78, 0x82, 0x28, 0x90, 0x42, 0xf8, 0x45, 0xb7, 0xbb, 0x33, 0x50, 0xa3, 0x6f, 0x55, 0xa3, 0x9c, 0xbe, 0x0e, 0xb0, 0x17, 0x6a, 0x52, 0xb5, 0xc7, 0x9b, 0xa1, 0xa1, 0x86, 0x6d, 0x28, 0xfb, 0x87, 0xc6, 0xe6, 0xe9, 0x0c, 0x3b, 0xf1, 0x64, 0xa9, 0x54, 0x15, 0xa9, 0x0c, 0xa7, 0xe2, 0xc7, 0x07, 0x42, 0xc5, 0xd0, 0x69, 0x5a, 0x9e, 0xd8, 0x01, 0x8c, 0x91, 0xf8, 0x1a, 0xf9, 0xd3, 0xb3, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x49, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xe7, 0xe2, 0x59, 0x0b, 0x37, 0x6f, 0x0c, 0x69, 0x98, 0x58, 0x8a, 0x75, 0xbf, 0x37, 0xf0, 0xfd, 0x0f, 0x31, 0x4b, 0xaf, 0x7e, 0x49, 0xbc, 0xe6, 0x37, 0xd3, 0x23, 0x7a, 0x17, 0x1b, 0x02, 0x7c, 0xce, 0x5b, 0x0a, 0xdb, 0x06, 0x6f, 0xd5, 0x71, 0x0c, 0x53, 0x4c, 0x44, 0x6e, 0xc4, 0x2d, 0x5a, 0xb6, 0xab, 0x18, 0x81, 0xde, 0x91, 0xf1, 0x88, 0x95, 0xa1, 0xa7, 0x3d, 0xc0, 0x0b, 0x94, 0x90, 0xb4, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x4a, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xc1, 0xdf, 0x8a, 0xe1, 0x8a, 0x08, 0x50, 0x32, 0x27, 0x0a, 0x79, 0x55, 0xb9, 0x57, 0x79, 0xb3, 0xdc, 0x18, 0x8c, 0x2b, 0x11, 0xd9, 0x1f, 0x35, 0x04, 0x3d, 0x57, 0x99, 0x82, 0x2b, 0xd0, 0x0e, 0x76, 0x89, 0x88, 0xe3, 0x63, 0x80, 0x75, 0x04, 0xcb, 0x4f, 0xf2, 0xbe, 0xe0, 0xb3, 0x87, 0x67, 0x25, 0x0a, 0xeb, 0x8e, 0x2a, 0x78, 0x3e, 0xfa, 0x91, 0x28, 0xae, 0xd6, 0x7f, 0x9f, 0x03, 0x30, 0xb4, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x4b, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x7c, 0x4c, 0xdc, 0x37, 0x4b, 0x98, 0x41, 0x2c, 0x61, 0xcb, 0x0a, 0x9f, 0xfc, 0x15, 0xea, 0x2b, 0xc2, 0xb6, 0xc9, 0x57, 0xbd, 0x64, 0xf3, 0x0e, 0x7d, 0xa7, 0x87, 0x97, 0xa5, 0x14, 0xf0, 0x14, 0xda, 0x8d, 0x36, 0x60, 0x66, 0xfd, 0xc3, 0x0d, 0xf7, 0x91, 0xb7, 0xbe, 0x1c, 0x73, 0xf9, 0x7d, 0x76, 0x2a, 0x3d, 0x1f, 0x1b, 0xde, 0x06, 0x50, 0x7a, 0x39, 0xba, 0x65, 0xe2, 0x21, 0x67, 0x40, 0xb4, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x04, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x4c, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x8e, 0xa0, 0xc3, 0x0c, 0xd8, 0xe4, 0x28, 0x5b, 0x6c, 0xec, 0xf7, 0xa0, 0x13, 0xa9, 0xcb, 0x1f, 0xb5, 0x98, 0x0c, 0xfa, 0x53, 0x61, 0x72, 0x00, 0x94, 0xc3, 0xf4, 0x63, 0x15, 0xdd, 0xea, 0x44, 0x02, 0x01, 0xa7, 0xe2, 0x78, 0xdc, 0x70, 0xcc, 0x18, 0x8e, 0x58, 0xaf, 0xae, 0x9a, 0x08, 0x0f, 0x5e, 0x98, 0x22, 0x54, 0xdc, 0x55, 0x6f, 0x22, 0xf4, 0xf1, 0x60, 0xcb, 0xfb, 0x2c, 0xe9, 0xb1, 0xb4, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x4d, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xb4, 0x9f, 0x1f, 0x28, 0x13, 0xfe, 0x4c, 0xf6, 0x0b, 0x84, 0x01, 0x3a, 0x7a, 0x66, 0xee, 0x80, 0x69, 0xfe, 0xf8, 0xfd, 0xe1, 0x58, 0x9f, 0x1b, 0xb7, 0x49, 0x1a, 0x80, 0x0c, 0xe1, 0x6d, 0x1d, 0x94, 0x38, 0x6b, 0xf1, 0x30, 0x0a, 0x23, 0x8e, 0x35, 0x22, 0x88, 0x6f, 0xc1, 0x80, 0x42, 0x32, 0xb1, 0x32, 0x3b, 0xf3, 0x9c, 0xd6, 0x35, 0x43, 0xbe, 0x53, 0x73, 0x9e, 0x96, 0xa6, 0x70, 0x58, 0xb4, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x4e, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xb9, 0xc5, 0x1f, 0xa8, 0x2b, 0x5f, 0x3b, 0xe2, 0x52, 0x7b, 0x4f, 0x36, 0x64, 0x2f, 0x99, 0x87, 0x80, 0xad, 0x74, 0x24, 0xac, 0xfd, 0xda, 0xdc, 0x45, 0x70, 0x82, 0xeb, 0x0c, 0x51, 0xaf, 0x33, 0xd3, 0x8e, 0x3e, 0x20, 0xe3, 0x2a, 0x81, 0x27, 0x98, 0xfb, 0x9c, 0x16, 0xd1, 0xff, 0x59, 0x78, 0xbb, 0x6a, 0x97, 0x00, 0xef, 0xce, 0x13, 0xc1, 0x71, 0xe6, 0xca, 0x1e, 0x4c, 0x7c, 0x61, 0x8c, 0xb4, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x05, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x4f, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x50, 0x87, 0x7e, 0x42, 0xef, 0x33, 0x4d, 0xbf, 0x29, 0x6d, 0x76, 0x55, 0xf5, 0x6d, 0x95, 0x97, 0xdd, 0xff, 0xa4, 0x9c, 0x26, 0x49, 0x70, 0x78, 0x19, 0xcd, 0x90, 0x89, 0x16, 0xb3, 0x16, 0x02, 0x6e, 0x0e, 0x9f, 0x16, 0x5f, 0xb9, 0x61, 0x49, 0xdc, 0x1c, 0xc6, 0x45, 0xec, 0x65, 0x1d, 0x2c, 0x48, 0x7f, 0x34, 0xcc, 0x59, 0xb3, 0x4a, 0xbd, 0xac, 0xa5, 0x5d, 0x0b, 0xb5, 0x24, 0x48, 0xf0, 0xb5, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x50, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x02, 0xeb, 0xa6, 0x42, 0x21, 0x7e, 0x71, 0xe9, 0x43, 0x34, 0x72, 0x36, 0x45, 0xa3, 0xdb, 0x39, 0x7f, 0x8c, 0x83, 0xa8, 0xb7, 0xdf, 0x5b, 0x4c, 0x7d, 0x12, 0xd5, 0x66, 0xdd, 0x85, 0x90, 0x14, 0xf6, 0xc8, 0xa9, 0x24, 0xf8, 0x8f, 0x3a, 0xae, 0xa0, 0xdb, 0xac, 0xb4, 0x10, 0xd9, 0xa9, 0xd7, 0x9d, 0xdb, 0x2b, 0x2d, 0x84, 0xce, 0xee, 0x10, 0x45, 0x39, 0xed, 0x26, 0x63, 0xf6, 0xff, 0x68, 0xb5, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x51, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x1e, 0x77, 0x2b, 0xcb, 0x91, 0xc4, 0x2f, 0x43, 0xcb, 0x65, 0xfa, 0x81, 0xcc, 0x72, 0x87, 0x6b, 0x4f, 0xd2, 0x0e, 0x59, 0xd5, 0x4c, 0xea, 0xdb, 0x92, 0x8d, 0x3a, 0x0d, 0x01, 0x82, 0x98, 0x24, 0x63, 0x8f, 0xdd, 0x74, 0x3a, 0x87, 0x36, 0x3f, 0x19, 0x44, 0x1b, 0xd7, 0xd3, 0xaf, 0x11, 0x93, 0xec, 0x94, 0xee, 0x31, 0xda, 0x28, 0x28, 0x9b, 0xc1, 0xbf, 0xc3, 0x7c, 0xe6, 0x29, 0x27, 0x56, 0xb5, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x52, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xcb, 0x68, 0x4c, 0x4d, 0x09, 0x35, 0x4f, 0x8d, 0x21, 0x73, 0x24, 0x0f, 0x3e, 0x40, 0x80, 0xb1, 0x1d, 0x81, 0x4d, 0x8d, 0x64, 0xab, 0x0b, 0x85, 0x1d, 0x0d, 0xfc, 0xa5, 0xb6, 0x7c, 0x02, 0x12, 0x64, 0xc0, 0xb4, 0xd2, 0x18, 0xb6, 0x3f, 0x9e, 0xf8, 0xfe, 0xbd, 0x0c, 0x82, 0x2d, 0x0c, 0x60, 0x92, 0x19, 0x68, 0x7d, 0x9a, 0x1d, 0x6a, 0xc2, 0xc7, 0x3f, 0x50, 0x50, 0x1a, 0x4d, 0xd8, 0x9c, 0xb5, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x53, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xb7, 0x76, 0xbb, 0xe1, 0x2a, 0x01, 0xc8, 0xd1, 0xd9, 0xe3, 0x0a, 0x8e, 0x4d, 0x56, 0x40, 0x74, 0xe9, 0x39, 0xaf, 0x2c, 0x88, 0xe5, 0x59, 0xcd, 0x1b, 0xcd, 0x88, 0xf9, 0x99, 0x43, 0xca, 0x33, 0xcf, 0x0e, 0x75, 0x6c, 0xf0, 0x3b, 0x0b, 0x23, 0xd9, 0xb6, 0x50, 0x53, 0xe3, 0x09, 0xa7, 0xa5, 0x4a, 0x26, 0xe4, 0x40, 0x3c, 0xd3, 0xa3, 0xd3, 0xd3, 0x15, 0x24, 0xa8, 0xaf, 0x15, 0x00, 0xe3, 0xb5, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x54, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x3d, 0x36, 0xbe, 0xe9, 0xd6, 0x95, 0xe4, 0xec, 0x54, 0xb8, 0x44, 0x2c, 0xb6, 0x2e, 0xc3, 0x06, 0x2c, 0xb0, 0x56, 0xd9, 0x53, 0x91, 0xfa, 0x73, 0xb6, 0x9f, 0x48, 0x67, 0xe8, 0x8c, 0x6b, 0x37, 0x69, 0x84, 0xa4, 0x22, 0x55, 0x07, 0x9b, 0x96, 0x90, 0x8a, 0xab, 0x4f, 0x4b, 0xc5, 0x17, 0x58, 0x52, 0xf3, 0xd5, 0x40, 0x01, 0xa4, 0x93, 0xd4, 0xf7, 0xa9, 0xd0, 0x9d, 0x4a, 0xff, 0x0a, 0xe3, 0xb5, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x55, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xf9, 0x12, 0xba, 0x81, 0x48, 0x81, 0x10, 0x35, 0x01, 0xd4, 0x9c, 0x3d, 0xf3, 0x8e, 0x24, 0xff, 0x54, 0x1f, 0x6b, 0xfc, 0x81, 0x6d, 0x4f, 0x8b, 0xb6, 0xdb, 0x17, 0x00, 0xed, 0xb6, 0xcb, 0x3d, 0xb1, 0x25, 0xa0, 0x62, 0x04, 0xd5, 0x69, 0x4b, 0xaf, 0x2c, 0x13, 0xcc, 0xaa, 0x2f, 0x06, 0x94, 0x1a, 0xdc, 0x3a, 0xe7, 0xd7, 0xf2, 0x44, 0x92, 0x12, 0x64, 0x4c, 0xea, 0x86, 0x59, 0xcc, 0x6d, 0xb6, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x56, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x8b, 0x91, 0x1f, 0xf2, 0x62, 0xdc, 0xe7, 0x4e, 0xe3, 0x21, 0xbf, 0x09, 0xdf, 0x07, 0xc3, 0x99, 0x30, 0xd5, 0x3a, 0x3a, 0x10, 0xfd, 0x83, 0xc7, 0x4e, 0xe4, 0xee, 0x6e, 0xae, 0x13, 0xa2, 0x35, 0x5e, 0x47, 0xb7, 0x88, 0x6c, 0x28, 0x39, 0xc9, 0xd5, 0x82, 0xd4, 0x9f, 0xdf, 0x35, 0x6a, 0x5c, 0x29, 0x8b, 0x3f, 0x7c, 0x87, 0x9f, 0xe4, 0x46, 0x7b, 0x01, 0xcf, 0x7f, 0x95, 0x16, 0x20, 0xd8, 0xb6, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x57, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x12, 0xe1, 0xe9, 0xa2, 0x99, 0x90, 0x71, 0x13, 0xc1, 0x00, 0xc3, 0x4c, 0xf5, 0x4b, 0xfa, 0xf5, 0x7a, 0x02, 0xc0, 0x76, 0x7e, 0xe5, 0x71, 0xd0, 0xb0, 0xd5, 0x86, 0x95, 0x7b, 0x86, 0x76, 0x32, 0xb1, 0x21, 0xf1, 0xd6, 0xfc, 0x22, 0xdc, 0xfa, 0x6f, 0xd8, 0x7c, 0xc5, 0xac, 0x11, 0x57, 0x9c, 0xf7, 0xf8, 0x15, 0x54, 0x53, 0x6c, 0x4e, 0x32, 0x6e, 0xad, 0xad, 0x0e, 0xce, 0x3c, 0xda, 0xa0, 0xb6, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x58, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xf4, 0xce, 0x3a, 0xa3, 0xf3, 0x8a, 0xef, 0x3c, 0x88, 0x6d, 0x51, 0x7a, 0x63, 0xa1, 0x6d, 0x47, 0xc4, 0x39, 0x26, 0x00, 0xca, 0xa8, 0x5f, 0xf6, 0x56, 0xa0, 0x82, 0x93, 0x80, 0xd0, 0x3e, 0x32, 0xa1, 0xa1, 0x28, 0x9f, 0x42, 0x16, 0xd8, 0x8b, 0xb0, 0x51, 0x4d, 0x52, 0x59, 0xb8, 0xf0, 0x3d, 0xcd, 0x05, 0xfb, 0xad, 0x65, 0x0b, 0xcf, 0xa5, 0x9c, 0xb1, 0x63, 0xff, 0x5b, 0x69, 0x8e, 0x8b, 0xb6, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x59, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xf5, 0x90, 0xec, 0x1e, 0x4d, 0x4e, 0x3e, 0xf1, 0x3a, 0x52, 0x0a, 0x71, 0xd6, 0x71, 0x75, 0xca, 0xd4, 0xb9, 0xa2, 0x79, 0xb0, 0xdc, 0xcc, 0xfa, 0xc4, 0x71, 0xc6, 0x58, 0xc9, 0x95, 0xaf, 0x04, 0x88, 0x75, 0x2a, 0xe7, 0x73, 0xa4, 0x15, 0x40, 0x22, 0x50, 0x7a, 0xed, 0x80, 0x6c, 0x7e, 0xe5, 0x04, 0x45, 0xa9, 0x22, 0x11, 0xb0, 0x2c, 0x10, 0xff, 0x86, 0x07, 0x0d, 0x35, 0x3a, 0xc9, 0x30, 0xb6, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x5a, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xfb, 0x36, 0xf6, 0x0f, 0x0a, 0x78, 0x8d, 0x22, 0xd2, 0x5a, 0xd7, 0x96, 0x23, 0x33, 0xe1, 0x07, 0xe1, 0x42, 0xc1, 0xe7, 0x97, 0x61, 0x45, 0x55, 0xa2, 0x5b, 0x3f, 0xab, 0xf2, 0xa5, 0x76, 0x33, 0xed, 0xe3, 0xca, 0xa7, 0x56, 0x96, 0x17, 0xff, 0xa4, 0x44, 0xd6, 0xd4, 0xbd, 0x3e, 0x2d, 0xba, 0x7e, 0x31, 0x08, 0x5b, 0x19, 0x76, 0xf1, 0x6d, 0x94, 0xc5, 0x37, 0xc1, 0xd3, 0x46, 0x2c, 0x0a, 0xb6, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x5b, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xc4, 0xf5, 0xc4, 0x92, 0xba, 0x5e, 0xe6, 0x20, 0xcb, 0xde, 0xce, 0xd3, 0xd2, 0xdd, 0xd6, 0xc6, 0xb3, 0xcd, 0x39, 0x4b, 0xac, 0xb1, 0xa9, 0x17, 0x77, 0x4a, 0x19, 0x04, 0x8e, 0x1e, 0xe6, 0x47, 0x32, 0xe5, 0x4e, 0xa8, 0x50, 0x2d, 0x51, 0xb0, 0x5b, 0xca, 0x7f, 0x98, 0x1c, 0x5a, 0xc0, 0xf3, 0x91, 0x8d, 0xd0, 0x2d, 0xc1, 0x78, 0x20, 0x6f, 0x36, 0x95, 0x7e, 0x6d, 0xaf, 0x2a, 0x81, 0x21, 0xb7, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x5c, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xcf, 0x0e, 0x39, 0xe1, 0x5d, 0xe4, 0x0d, 0x78, 0x0a, 0xc3, 0xbb, 0x7e, 0xb6, 0x58, 0xa2, 0xd9, 0x3d, 0x3f, 0x62, 0x66, 0xfa, 0xe1, 0x14, 0xf9, 0x19, 0xfc, 0x34, 0x3d, 0x08, 0x37, 0x4c, 0x09, 0x6c, 0x4d, 0x12, 0xd3, 0xe9, 0x56, 0xa9, 0x54, 0x99, 0xd4, 0x6b, 0xd5, 0x78, 0x1b, 0x02, 0x56, 0x1d, 0xa3, 0xc7, 0x4c, 0xdb, 0x77, 0x15, 0xf0, 0xe5, 0xc1, 0xb6, 0x49, 0x19, 0x7c, 0x7c, 0x86, 0xb7, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x5d, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xad, 0x64, 0xf0, 0xc5, 0x19, 0xb5, 0x9e, 0xad, 0x1d, 0xd2, 0x44, 0x7e, 0xba, 0x48, 0xda, 0xcc, 0xb1, 0x25, 0x0a, 0xd8, 0x3f, 0x9f, 0x1d, 0x2a, 0x4e, 0x68, 0x70, 0x85, 0xd0, 0x99, 0x18, 0x10, 0x24, 0x52, 0x9c, 0x67, 0xba, 0x91, 0x64, 0x43, 0x39, 0x4c, 0x23, 0x13, 0x8c, 0x72, 0x02, 0x97, 0x07, 0x50, 0xc8, 0x6f, 0x8e, 0xdb, 0xc8, 0x1e, 0x99, 0x03, 0xa7, 0x5e, 0x50, 0x9c, 0xbc, 0x41, 0xb7, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x5e, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x5a, 0x11, 0x16, 0xda, 0x77, 0x0d, 0x72, 0xfb, 0xda, 0x72, 0xb3, 0x91, 0x79, 0x31, 0x2f, 0x45, 0xb3, 0xd3, 0xfb, 0x71, 0xe2, 0x49, 0x2d, 0xe5, 0x40, 0x17, 0x15, 0xd8, 0x12, 0x16, 0xef, 0x08, 0x77, 0xe2, 0x4b, 0x23, 0xc5, 0x38, 0x57, 0x08, 0x50, 0x10, 0x84, 0x45, 0x17, 0x3c, 0xfb, 0xa3, 0xc5, 0xba, 0xa6, 0xee, 0x6a, 0xf1, 0x6f, 0x80, 0x7e, 0x7f, 0x56, 0xb7, 0x72, 0xbb, 0x29, 0x33, 0xb7, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x5f, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x51, 0x33, 0xfd, 0x56, 0x75, 0x93, 0xe6, 0xd4, 0xab, 0xd3, 0x59, 0x9c, 0x4a, 0xaf, 0xd0, 0x23, 0x14, 0x15, 0x16, 0x5f, 0x82, 0xd2, 0x9a, 0x0a, 0x1c, 0xf4, 0xc4, 0x3e, 0x7f, 0xdd, 0xdb, 0x68, 0xa3, 0x71, 0xd4, 0x8b, 0x5a, 0xf5, 0x14, 0x7d, 0x8c, 0xf8, 0xf4, 0x48, 0x9d, 0x62, 0x69, 0x85, 0xd6, 0x42, 0x0f, 0x85, 0x1b, 0xda, 0x7e, 0x70, 0xcc, 0xde, 0xd3, 0xf9, 0x55, 0x66, 0xcc, 0xd9, 0xb7, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x60, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x8d, 0x41, 0x77, 0x0b, 0xb4, 0x4e, 0xa7, 0xf1, 0x3f, 0x2a, 0x4b, 0x67, 0x9d, 0xd3, 0xaf, 0x01, 0xff, 0xe7, 0x6f, 0xfa, 0xe2, 0xb4, 0xc3, 0xe2, 0x6c, 0xee, 0x30, 0x8c, 0x1b, 0x76, 0xbd, 0x53, 0x33, 0xa5, 0x03, 0x8c, 0xd8, 0x1c, 0xaf, 0x8e, 0x51, 0x5c, 0x5f, 0x6c, 0xbe, 0xd9, 0x4a, 0xd8, 0x90, 0x5b, 0xad, 0x2b, 0x17, 0xbd, 0xfd, 0x03, 0x27, 0xbb, 0x1c, 0xf4, 0x1f, 0x30, 0x6a, 0xcc, 0xb7, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x61, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x2f, 0x33, 0x14, 0x7c, 0xa2, 0xf7, 0x55, 0xaf, 0x1d, 0x9f, 0x28, 0x36, 0x05, 0x96, 0x20, 0xdb, 0x68, 0x7b, 0x6d, 0x97, 0xcf, 0x85, 0xd8, 0x32, 0xc2, 0x29, 0x01, 0xaa, 0xaa, 0xda, 0xa4, 0x25, 0x84, 0xb8, 0x8b, 0x07, 0x32, 0xce, 0x3d, 0x9f, 0x69, 0xab, 0x20, 0x67, 0x42, 0xb3, 0x48, 0xee, 0x96, 0xa6, 0xfb, 0xc6, 0x3c, 0x28, 0x8f, 0x14, 0x79, 0x5a, 0x82, 0x21, 0x54, 0x8c, 0xde, 0x6c, 0xb8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x62, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x9a, 0xba, 0x32, 0x9a, 0x81, 0x8d, 0x2e, 0xb0, 0x1d, 0xa9, 0x85, 0xe4, 0x97, 0x05, 0x0e, 0xb3, 0xd3, 0x81, 0xd1, 0x04, 0x67, 0x4e, 0xef, 0xee, 0xd2, 0xea, 0x14, 0xf2, 0x53, 0x1b, 0x87, 0x16, 0x66, 0x86, 0x88, 0xa5, 0xf4, 0x54, 0x5d, 0x86, 0xd0, 0x0b, 0xde, 0xbb, 0x0a, 0x00, 0x7c, 0xaf, 0xc5, 0x30, 0x60, 0x3c, 0x1f, 0xbb, 0x6d, 0x6a, 0x9f, 0x06, 0x9a, 0x1d, 0x5f, 0x10, 0x9f, 0xd0, 0xb8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x63, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x71, 0xc8, 0x04, 0xf1, 0x77, 0x41, 0x0c, 0x99, 0x42, 0xf1, 0xdf, 0x0b, 0xc8, 0x91, 0xb9, 0xae, 0x65, 0x50, 0x82, 0x12, 0x54, 0x88, 0xdf, 0x7e, 0x5c, 0x79, 0x57, 0x4c, 0x9a, 0xd5, 0xa8, 0x3b, 0x8e, 0x75, 0x09, 0xe2, 0x25, 0xf8, 0x97, 0x0e, 0xcd, 0x56, 0x38, 0xf9, 0x68, 0x93, 0x45, 0x60, 0xa3, 0xb9, 0x9f, 0x6a, 0x3e, 0xc0, 0x3a, 0x5d, 0xca, 0x7a, 0x9d, 0xb5, 0x33, 0x1c, 0xa7, 0x13, 0xb8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x64, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x61, 0x7c, 0x46, 0x98, 0xf1, 0xf9, 0xb2, 0xa5, 0x2f, 0xe2, 0x18, 0x2c, 0xec, 0x78, 0xf4, 0x69, 0x32, 0x4a, 0x71, 0x1c, 0xec, 0xac, 0x03, 0x01, 0x3a, 0xaa, 0xd0, 0x08, 0x98, 0x35, 0xa9, 0x16, 0xf9, 0x12, 0x65, 0x03, 0xbe, 0x10, 0x01, 0x08, 0x01, 0x02, 0xab, 0x12, 0x2a, 0x12, 0x3a, 0x6c, 0xcd, 0xff, 0x5a, 0x94, 0x01, 0x7c, 0x15, 0xa6, 0xf1, 0x40, 0x12, 0xfb, 0xb8, 0xa8, 0xfd, 0x78, 0xb8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x65, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xe5, 0x46, 0x49, 0xf5, 0xad, 0xf5, 0x9d, 0xfb, 0x18, 0xfd, 0x13, 0x70, 0x43, 0x4c, 0xc7, 0x6e, 0xf9, 0xa4, 0x53, 0x76, 0x2b, 0x17, 0xa4, 0x35, 0xda, 0xfb, 0x58, 0x0a, 0x19, 0xa5, 0xb8, 0x68, 0xcb, 0x06, 0x77, 0x47, 0xf9, 0xa3, 0x55, 0x80, 0x43, 0x35, 0x08, 0x4c, 0x65, 0x2f, 0x93, 0x54, 0x88, 0x67, 0xe0, 0x20, 0x50, 0xfb, 0xce, 0xc3, 0xc0, 0xcc, 0xb0, 0x56, 0x57, 0xce, 0x66, 0x6a, 0xb8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x66, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x67, 0x23, 0x2d, 0x98, 0x58, 0x89, 0x7d, 0x86, 0xa1, 0x55, 0xb9, 0x2f, 0xb9, 0x4b, 0x42, 0x35, 0x3d, 0x76, 0x5f, 0x0d, 0x2e, 0xaa, 0x09, 0x54, 0x60, 0xa1, 0xce, 0x29, 0x7c, 0x38, 0x63, 0x05, 0x1e, 0x31, 0xf4, 0x63, 0xb5, 0x07, 0x7e, 0xbd, 0xac, 0x12, 0x95, 0xd5, 0x64, 0x61, 0x02, 0x8f, 0xec, 0x70, 0xe8, 0x02, 0x28, 0x96, 0xc5, 0x4c, 0xd1, 0x72, 0xa1, 0xfa, 0x68, 0x5d, 0xda, 0xef, 0xb8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x05, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x67, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x29, 0x45, 0x79, 0x5c, 0x2d, 0xd6, 0xb0, 0xc4, 0x7c, 0x96, 0xd8, 0xce, 0x65, 0xf0, 0x08, 0x3c, 0xf2, 0x0c, 0xd5, 0x76, 0x06, 0x22, 0xb5, 0x9e, 0xe8, 0x95, 0xef, 0xf3, 0x3b, 0x8d, 0x1a, 0x36, 0xec, 0x51, 0xa1, 0xa1, 0xa9, 0x9a, 0x97, 0x14, 0x37, 0xb3, 0xd2, 0x4f, 0x06, 0x19, 0x06, 0x08, 0xcc, 0x26, 0x46, 0x84, 0x2e, 0x3b, 0x3f, 0xda, 0x0b, 0x00, 0xdf, 0x45, 0x0f, 0x59, 0xeb, 0xb2, 0xb9, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x68, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x4a, 0x4d, 0xfd, 0x3c, 0xea, 0xb2, 0x92, 0x99, 0xd0, 0xc6, 0x07, 0xc8, 0x12, 0xab, 0x26, 0x26, 0xcc, 0x1a, 0x84, 0x16, 0x87, 0x0f, 0x5a, 0xce, 0xdb, 0x9b, 0x81, 0xba, 0xc3, 0x80, 0x72, 0x71, 0xf4, 0x00, 0xa1, 0xa5, 0x6b, 0x15, 0xe9, 0x90, 0xc5, 0x16, 0xb2, 0x9a, 0x50, 0xa9, 0xa3, 0x72, 0x5f, 0xfa, 0x77, 0xea, 0x16, 0x61, 0xfe, 0xcd, 0x37, 0xce, 0xa2, 0xe7, 0x4c, 0x8d, 0x2b, 0x9d, 0xb9, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x69, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xb3, 0xbf, 0xe4, 0xaf, 0xe3, 0x3b, 0x5e, 0x0b, 0xbe, 0x6f, 0x43, 0x68, 0xe2, 0xe2, 0xb8, 0x8a, 0x2b, 0xae, 0x14, 0x0c, 0x03, 0xc8, 0x11, 0xe8, 0x7c, 0xe5, 0xcc, 0xa6, 0x90, 0xe3, 0xe3, 0x14, 0x06, 0xb8, 0x7a, 0x9f, 0x1d, 0x8a, 0x9d, 0x7a, 0xf6, 0x21, 0x4f, 0x09, 0x16, 0x78, 0x57, 0xf2, 0x0c, 0x61, 0xc8, 0x42, 0xd9, 0xf9, 0x23, 0x1e, 0x53, 0x99, 0xe4, 0x33, 0x60, 0x40, 0xfb, 0x04, 0xb9, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x6a, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xa3, 0x2a, 0x6b, 0x2a, 0x89, 0x2b, 0x68, 0x9d, 0xf1, 0x4f, 0x7c, 0x9c, 0x03, 0x41, 0x0d, 0x3d, 0x3f, 0x93, 0x17, 0x0e, 0x7e, 0x52, 0xfd, 0xe7, 0x4d, 0x04, 0x4c, 0x1e, 0x26, 0xa1, 0x26, 0x31, 0x68, 0xb9, 0xd3, 0x2c, 0xd7, 0xaa, 0x75, 0x07, 0xc3, 0x17, 0x58, 0x10, 0x4c, 0xc2, 0x61, 0x52, 0x50, 0xfd, 0x24, 0xf3, 0xb5, 0x2c, 0xb8, 0x87, 0x66, 0x6f, 0xf6, 0xf0, 0xec, 0x67, 0xe8, 0x1c, 0xb9, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x6b, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x8a, 0x6e, 0xba, 0x5c, 0xce, 0xcf, 0xd3, 0x49, 0x72, 0x34, 0xd5, 0xa3, 0xe2, 0x61, 0x34, 0x32, 0x21, 0x9c, 0x17, 0x41, 0x59, 0x74, 0x08, 0x9a, 0x4b, 0xc5, 0x7e, 0x20, 0x63, 0xa8, 0xef, 0x05, 0x07, 0x4c, 0x42, 0xc4, 0x56, 0xbd, 0xf4, 0xc1, 0xc1, 0x63, 0xf1, 0xc5, 0xf9, 0x44, 0x97, 0x10, 0xec, 0x4b, 0xdf, 0x2a, 0x23, 0x5c, 0x8c, 0x77, 0xb8, 0xac, 0xb0, 0xec, 0xdf, 0x13, 0xe9, 0xc5, 0xb9, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x6c, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x01, 0xac, 0xb7, 0x07, 0x79, 0xeb, 0x9d, 0x2e, 0xa4, 0x7e, 0x0f, 0x4d, 0x71, 0x2f, 0x3c, 0x53, 0xed, 0x5a, 0xdc, 0xe6, 0xa5, 0x64, 0x8f, 0x34, 0x24, 0xf9, 0xfd, 0x45, 0xc3, 0xaf, 0xe6, 0x19, 0xe4, 0xf0, 0xe5, 0x0d, 0x89, 0xb2, 0x09, 0xa2, 0x5f, 0xca, 0x68, 0x1b, 0xe5, 0x3f, 0x69, 0xea, 0x2b, 0xe9, 0xa7, 0x7f, 0x7f, 0x90, 0xda, 0xb1, 0xfe, 0xdf, 0x18, 0x96, 0x30, 0x91, 0x3d, 0xc1, 0xb9, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x6d, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xd7, 0x1e, 0x5b, 0x9e, 0x74, 0xa1, 0x51, 0xb7, 0x8b, 0x3a, 0x08, 0xb8, 0x92, 0xfb, 0x6c, 0x42, 0x41, 0x3e, 0x72, 0x67, 0x82, 0x45, 0xb6, 0x9f, 0xb3, 0x36, 0xd0, 0x5d, 0x2c, 0xe9, 0x5e, 0x2e, 0x0a, 0x44, 0x8a, 0xa9, 0x72, 0x00, 0xb2, 0xd8, 0xed, 0x8f, 0x31, 0xdf, 0x63, 0xf6, 0x25, 0x8c, 0x37, 0xcc, 0x4e, 0x57, 0xf1, 0x0b, 0xf3, 0x91, 0x51, 0x36, 0x46, 0xf4, 0x58, 0x83, 0x09, 0x93, 0xba, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x6e, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x56, 0x5d, 0xe0, 0x25, 0x75, 0x65, 0x20, 0x25, 0x98, 0xc3, 0xf6, 0x94, 0xbf, 0x1a, 0x70, 0x16, 0xd4, 0x9a, 0x7c, 0x6d, 0xde, 0xeb, 0x11, 0x44, 0x76, 0xec, 0x45, 0x2f, 0xda, 0x62, 0x23, 0x19, 0x28, 0xc5, 0xaa, 0x1a, 0xb3, 0x10, 0xa7, 0xf5, 0x6b, 0x5f, 0x27, 0x19, 0xf9, 0x32, 0x9b, 0x2b, 0x45, 0x47, 0xa1, 0x9b, 0x31, 0xa3, 0x78, 0xb5, 0x2d, 0x35, 0x83, 0xa9, 0x61, 0xf1, 0xe9, 0x61, 0xba, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x6f, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x1b, 0x71, 0x9f, 0xad, 0x53, 0x6a, 0x1e, 0x8d, 0x48, 0x5b, 0x15, 0x9a, 0xfa, 0x80, 0x42, 0x91, 0x28, 0x24, 0xcd, 0x38, 0xe3, 0x0b, 0xb6, 0xe0, 0x84, 0xcb, 0x2d, 0x26, 0x75, 0x31, 0xf5, 0x78, 0xdf, 0x5a, 0xe1, 0xd4, 0xbd, 0x3c, 0x57, 0xf4, 0x8a, 0xf2, 0x25, 0xd7, 0x38, 0xad, 0x22, 0xc7, 0x41, 0xaf, 0x78, 0xb7, 0x7c, 0x80, 0xb5, 0x8b, 0xa5, 0x89, 0xed, 0x86, 0xc2, 0x14, 0x60, 0x2f, 0xba, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x70, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xf4, 0x04, 0xdf, 0x02, 0xce, 0x88, 0xcd, 0x26, 0x8e, 0xd6, 0x6c, 0x9a, 0xcb, 0x0d, 0x67, 0x46, 0x83, 0x18, 0x53, 0x4f, 0x1e, 0x27, 0xe7, 0x7d, 0x97, 0xbd, 0x5b, 0x60, 0x39, 0x0c, 0x96, 0x78, 0xa5, 0xb3, 0x54, 0xdb, 0x44, 0xb6, 0x9a, 0x99, 0xdf, 0x4a, 0x92, 0xe3, 0xc4, 0x9c, 0xce, 0x01, 0x86, 0x9d, 0xf2, 0x31, 0x01, 0x3d, 0xda, 0xaa, 0xb5, 0xe3, 0xf1, 0xbc, 0x03, 0xd8, 0x12, 0x94, 0xba, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x71, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x28, 0x3f, 0xce, 0x50, 0x9e, 0x2e, 0xf4, 0x68, 0x4d, 0x51, 0x11, 0x30, 0x3f, 0x96, 0x8f, 0xe5, 0xb3, 0x96, 0x4c, 0x6d, 0x87, 0xeb, 0xad, 0x2c, 0x0f, 0x2f, 0xd4, 0x54, 0x54, 0x81, 0x49, 0x05, 0x4d, 0xbe, 0x5c, 0x69, 0x14, 0x0b, 0xc6, 0x62, 0xc9, 0x0e, 0xde, 0x02, 0xf1, 0x8a, 0x55, 0x58, 0xad, 0xc0, 0x04, 0x7f, 0xf8, 0xea, 0xcb, 0xa6, 0x4a, 0xae, 0xa4, 0xe0, 0x40, 0xed, 0x86, 0x7d, 0xba, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x72, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x93, 0xeb, 0x73, 0x7c, 0xdd, 0x90, 0xca, 0x58, 0x21, 0x28, 0x0c, 0xd7, 0x1e, 0x2b, 0xfb, 0xde, 0xf5, 0x49, 0xc1, 0xe6, 0xba, 0x38, 0x0f, 0x03, 0xfd, 0xc1, 0xcc, 0xca, 0xc4, 0x05, 0x9b, 0x25, 0x60, 0x03, 0x5e, 0x74, 0xa3, 0xf8, 0x97, 0x39, 0x0f, 0x93, 0xb6, 0xed, 0x88, 0x25, 0x0a, 0x1c, 0x21, 0x36, 0xed, 0x51, 0x6f, 0xeb, 0x5a, 0x2a, 0x47, 0xfb, 0xed, 0x95, 0x5e, 0x98, 0xbd, 0x47, 0xba, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x73, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x01, 0x1f, 0xc8, 0xdf, 0x4a, 0x0c, 0x62, 0xa8, 0x41, 0x43, 0x1c, 0x4c, 0x45, 0xf5, 0x43, 0x2a, 0xe9, 0x69, 0x28, 0x8b, 0x81, 0xaf, 0x3c, 0x1d, 0xab, 0xc8, 0xee, 0x1b, 0xc8, 0x6e, 0xf0, 0x50, 0x37, 0x5c, 0x54, 0xb2, 0xae, 0x53, 0x54, 0x67, 0xd9, 0x17, 0x9f, 0xd3, 0x86, 0xee, 0x6d, 0x9c, 0x4b, 0x33, 0xb1, 0x6e, 0xa1, 0x2f, 0x88, 0xf6, 0x25, 0x65, 0x26, 0xda, 0x16, 0x36, 0xf1, 0x91, 0xbb, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x74, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x88, 0x5c, 0x04, 0x0f, 0xa4, 0x47, 0x40, 0x51, 0x5f, 0xbe, 0x31, 0x02, 0xea, 0x30, 0xfb, 0x4c, 0x2b, 0xaa, 0x11, 0x7e, 0x84, 0xfe, 0xc2, 0x5d, 0x92, 0x16, 0xb0, 0x11, 0xea, 0x36, 0xd2, 0x71, 0xc6, 0x2f, 0xc5, 0x54, 0x85, 0x22, 0x3a, 0x48, 0x4f, 0x89, 0xea, 0x0d, 0x4d, 0xac, 0xf6, 0x8c, 0xc5, 0x3f, 0xbc, 0x6a, 0xf9, 0x8b, 0xf3, 0x17, 0x53, 0x38, 0xc5, 0xdb, 0x05, 0xa4, 0xcf, 0xc0, 0xbb, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x75, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xef, 0x3f, 0xda, 0xc7, 0x3d, 0x38, 0xf9, 0x44, 0x6f, 0x5d, 0x2a, 0x10, 0x65, 0xdd, 0x90, 0x20, 0xc0, 0x26, 0x9a, 0x44, 0xb5, 0xe3, 0x56, 0x48, 0xf4, 0x4e, 0x8b, 0x1b, 0x86, 0xd7, 0xc1, 0x5c, 0x8e, 0xb1, 0x0a, 0x61, 0x3b, 0xe6, 0x13, 0x46, 0x8b, 0x8d, 0xb3, 0xc7, 0x0f, 0xe2, 0x87, 0x1f, 0xa6, 0x7d, 0x65, 0x26, 0xa3, 0xb4, 0xf1, 0x1e, 0x73, 0x69, 0x22, 0xd8, 0x27, 0x8a, 0x82, 0xc1, 0xbb, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x76, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x6e, 0xe6, 0xd9, 0x4e, 0xeb, 0xdb, 0x09, 0x74, 0x65, 0x0c, 0xae, 0x85, 0xc9, 0xd4, 0xcd, 0x03, 0x5e, 0x07, 0x03, 0x1e, 0x69, 0x18, 0x12, 0x8e, 0x7d, 0xaf, 0xb8, 0x08, 0xfb, 0x9d, 0xc4, 0x12, 0x84, 0x65, 0x3f, 0xf9, 0xbf, 0x84, 0x23, 0x7a, 0xd6, 0xa8, 0x4c, 0xf6, 0xcf, 0x98, 0x17, 0xd3, 0xa3, 0x61, 0xd8, 0x05, 0xdb, 0x6c, 0xd3, 0xda, 0xf7, 0x66, 0x5e, 0x92, 0xed, 0x00, 0x42, 0x1b, 0xbb, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x77, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xa8, 0xc7, 0xd8, 0x43, 0x5a, 0x99, 0x87, 0x1c, 0x45, 0x68, 0x0b, 0x46, 0x4b, 0x02, 0xd8, 0x61, 0x8b, 0x23, 0xab, 0x0a, 0xc3, 0xdf, 0xeb, 0x93, 0x92, 0x6e, 0x54, 0xcc, 0xc9, 0x15, 0x28, 0x63, 0x3d, 0xc2, 0x6c, 0xc6, 0xc6, 0x89, 0x5a, 0xbe, 0x5d, 0xab, 0x4a, 0x63, 0x02, 0xcd, 0x19, 0x2f, 0x40, 0xe9, 0xdf, 0x84, 0x04, 0xad, 0x4b, 0x14, 0x25, 0xca, 0x7d, 0x6c, 0x2b, 0x5c, 0x9c, 0x18, 0xbb, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x78, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x88, 0x80, 0xa1, 0x80, 0x81, 0x63, 0xe8, 0x47, 0xdb, 0x25, 0xda, 0x39, 0xea, 0x5e, 0x8a, 0x50, 0x5d, 0x7c, 0xe3, 0x90, 0xa3, 0xb2, 0xdd, 0x36, 0x3b, 0x02, 0x32, 0xae, 0x19, 0x89, 0x6c, 0x27, 0x4c, 0xa9, 0x07, 0x49, 0xf6, 0xd4, 0x97, 0x4e, 0xa2, 0x3a, 0x24, 0x74, 0x02, 0xd6, 0x38, 0x47, 0x9a, 0x5e, 0xac, 0xdc, 0x3c, 0x15, 0xa0, 0x50, 0x69, 0x1a, 0xcb, 0x3f, 0xef, 0xa4, 0x4a, 0x7f, 0xbb, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x79, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x7d, 0x58, 0x85, 0x3f, 0xf9, 0x4a, 0xdd, 0x55, 0x23, 0x48, 0x09, 0xe8, 0x2d, 0x5e, 0xd0, 0x8b, 0x33, 0x0e, 0xbb, 0xbb, 0x6f, 0x21, 0x58, 0x7f, 0x07, 0x28, 0xe2, 0xa1, 0x64, 0x53, 0x1f, 0x73, 0x5d, 0x9b, 0xac, 0x48, 0xf7, 0x06, 0x9d, 0x5d, 0x36, 0xf8, 0xa6, 0xf3, 0x9c, 0x41, 0xdc, 0xe3, 0x6c, 0x4f, 0xaa, 0x1a, 0x0c, 0x65, 0x31, 0x80, 0x27, 0x97, 0xbd, 0x8a, 0x32, 0xae, 0x96, 0xaf, 0xbc, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x7a, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x35, 0x74, 0xbd, 0x3a, 0x51, 0x08, 0x91, 0xf0, 0x20, 0x32, 0x82, 0x17, 0x90, 0x50, 0x92, 0x6b, 0x51, 0x1c, 0x02, 0x0e, 0xc1, 0x36, 0x01, 0x53, 0xe1, 0x75, 0x5b, 0x58, 0x47, 0xc5, 0x96, 0x41, 0x0a, 0xcd, 0xfc, 0xa8, 0x2e, 0xec, 0x93, 0x2a, 0x8b, 0x4d, 0x84, 0x87, 0xb0, 0x40, 0x1c, 0xa6, 0x7e, 0x28, 0x1f, 0x00, 0x7f, 0x5e, 0xe1, 0x6a, 0x28, 0x3b, 0xb5, 0xc8, 0x48, 0xd0, 0x51, 0xe6, 0xbc, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x7b, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x7e, 0x32, 0x69, 0xb3, 0x41, 0x6c, 0x62, 0x8d, 0x05, 0x5c, 0x6f, 0x07, 0x89, 0x59, 0xb4, 0x91, 0x56, 0x3a, 0xcb, 0x9f, 0xa8, 0x80, 0xe2, 0x7d, 0xee, 0x16, 0x29, 0x57, 0x9c, 0x0a, 0x53, 0x19, 0xad, 0x12, 0xcb, 0x82, 0x1d, 0x86, 0x91, 0x54, 0xd3, 0x68, 0x36, 0x3e, 0x67, 0x73, 0x29, 0x72, 0x97, 0x94, 0xad, 0x9a, 0xe5, 0x54, 0xc1, 0x48, 0x9f, 0xd7, 0x16, 0x5f, 0xeb, 0x29, 0x42, 0xd8, 0xbc, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x7c, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x67, 0x85, 0xe9, 0x99, 0xe7, 0x0d, 0x48, 0x54, 0x58, 0xad, 0x51, 0x1b, 0x5d, 0x2f, 0x16, 0xbd, 0x66, 0x59, 0x55, 0x97, 0xff, 0xd0, 0xb6, 0x37, 0xec, 0x00, 0x44, 0x3b, 0xf5, 0xfa, 0xcb, 0x03, 0xc9, 0x69, 0xe2, 0x5f, 0x87, 0xb2, 0x32, 0xfc, 0x4d, 0x25, 0x6c, 0x1e, 0x23, 0x66, 0x05, 0x2f, 0xc7, 0xf6, 0xec, 0x34, 0x92, 0x4f, 0x2d, 0x1c, 0xe7, 0x4a, 0x9f, 0x83, 0x91, 0xcf, 0x13, 0xdd, 0xbc, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x7d, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xf3, 0x81, 0xfa, 0x4b, 0xcb, 0xe9, 0xd7, 0xe2, 0xfd, 0x4d, 0x17, 0x32, 0xe3, 0xfe, 0x21, 0xf5, 0x7d, 0x46, 0x6d, 0xaf, 0xd4, 0xbc, 0x84, 0x7a, 0x1a, 0xcc, 0xaf, 0x54, 0x9e, 0xd1, 0xed, 0x2a, 0x9c, 0x6d, 0x6d, 0x16, 0x88, 0x2a, 0x64, 0xc7, 0x2c, 0xcc, 0xa6, 0xa0, 0xf6, 0xef, 0x50, 0x94, 0x95, 0x0a, 0x2b, 0x2a, 0xc9, 0xde, 0x68, 0x39, 0xb9, 0xe4, 0xa8, 0xdc, 0x3f, 0x1f, 0x5a, 0x9e, 0xbc, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x7e, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x15, 0x98, 0x2b, 0x33, 0xb2, 0x32, 0xe1, 0x6e, 0x06, 0x39, 0x40, 0x21, 0x94, 0xbf, 0xe5, 0x9c, 0xa4, 0x42, 0xfa, 0x5e, 0xee, 0x09, 0x08, 0xe1, 0x73, 0x75, 0xa6, 0x39, 0xe2, 0x19, 0x76, 0x49, 0x27, 0x53, 0xbc, 0xc2, 0x03, 0x25, 0xac, 0x44, 0xa5, 0xf4, 0x86, 0xcd, 0x4c, 0x41, 0x7d, 0xd4, 0x69, 0xd1, 0x65, 0xfd, 0x4e, 0xdc, 0xa4, 0xf6, 0x20, 0x08, 0x45, 0x54, 0x7d, 0xfa, 0xdb, 0xdf, 0xbc, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x01, 0x7f, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xfd, 0xca, 0x19, 0x40, 0xe5, 0x3d, 0x9d, 0x93, 0x2d, 0xee, 0x84, 0x75, 0xfe, 0x4d, 0x22, 0x26, 0x8d, 0xdf, 0x7c, 0x1f, 0x75, 0x79, 0x24, 0x45, 0xfd, 0xb1, 0xd0, 0x6c, 0x81, 0x0f, 0x82, 0x32, 0xe7, 0xf4, 0x42, 0x2c, 0x02, 0xd7, 0x18, 0x50, 0xc1, 0x14, 0x1d, 0xa1, 0x9d, 0x6f, 0x25, 0xf3, 0xcd, 0xe4, 0xd9, 0x8c, 0x43, 0xa7, 0x18, 0x31, 0x5b, 0x3a, 0xe4, 0x97, 0x19, 0xb9, 0xdb, 0x69, 0xbd, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x80, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xd9, 0xec, 0xf9, 0x17, 0x13, 0x10, 0x51, 0xe0, 0xe7, 0xb5, 0xe5, 0x8c, 0x35, 0x1d, 0x97, 0x20, 0xbd, 0x25, 0xea, 0xba, 0x55, 0x2d, 0x24, 0xbd, 0x8c, 0x82, 0xc6, 0xcd, 0x71, 0x52, 0x6c, 0x0f, 0x8b, 0x6a, 0x35, 0xe7, 0x52, 0x09, 0x82, 0x79, 0x5e, 0x00, 0x48, 0xf2, 0x33, 0x7b, 0x25, 0x75, 0xa7, 0x71, 0x6c, 0xb4, 0x90, 0x28, 0x35, 0xbf, 0x69, 0xe2, 0xe2, 0x0f, 0xd0, 0xc8, 0xb8, 0xa0, 0xbd, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x81, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xe4, 0xac, 0x05, 0x76, 0xea, 0xb0, 0xda, 0xda, 0xd6, 0x15, 0xce, 0x68, 0x7c, 0xc9, 0x21, 0x64, 0x36, 0x8a, 0x8a, 0x02, 0x4f, 0xd6, 0xcd, 0xe8, 0xaa, 0x6b, 0x00, 0x4d, 0x9e, 0x5e, 0x32, 0x4d, 0x9d, 0x55, 0x71, 0x18, 0x09, 0x45, 0x6c, 0xbd, 0xd0, 0x53, 0xae, 0xf9, 0xec, 0xda, 0xaa, 0x6b, 0x1e, 0xd0, 0x18, 0x43, 0xfc, 0xd0, 0x18, 0x0a, 0x78, 0x37, 0x59, 0x36, 0x28, 0xff, 0x6d, 0xec, 0xbd, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x82, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xe0, 0xea, 0x9b, 0x2c, 0xff, 0xf8, 0xa4, 0x97, 0x71, 0x8a, 0x1e, 0xc6, 0x6d, 0x72, 0x57, 0xd5, 0x62, 0x14, 0xe1, 0x7f, 0xce, 0x3b, 0xca, 0xf7, 0xd7, 0x50, 0x7e, 0x6a, 0x10, 0x4e, 0x57, 0x68, 0xaf, 0x3f, 0x25, 0xf4, 0x67, 0xa2, 0x6a, 0xb1, 0xbc, 0xd4, 0x4c, 0x62, 0x7a, 0x61, 0xdd, 0x7c, 0x61, 0x43, 0xaf, 0x28, 0x47, 0x77, 0x8f, 0x98, 0x54, 0x04, 0x9c, 0xec, 0x23, 0xd7, 0x34, 0x20, 0xbd, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x83, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xa6, 0xeb, 0x92, 0x7d, 0x1f, 0x8a, 0x63, 0x61, 0xf4, 0x65, 0x3f, 0x99, 0x49, 0x5c, 0xc2, 0x71, 0xc7, 0xe9, 0xe7, 0x0f, 0x58, 0xda, 0xa8, 0xd5, 0x40, 0x22, 0x97, 0x8e, 0x2c, 0x59, 0xee, 0x2f, 0x4f, 0x58, 0x27, 0x41, 0x92, 0xe2, 0xe8, 0x8e, 0xe2, 0x48, 0xb8, 0x35, 0xab, 0x8a, 0xd4, 0x10, 0x81, 0x73, 0x69, 0xc0, 0x7e, 0x12, 0x17, 0xbb, 0x4b, 0xcb, 0x2f, 0x1b, 0x17, 0xed, 0xbf, 0x2e, 0xbd, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x84, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x51, 0x53, 0x4f, 0x84, 0x72, 0x63, 0xfc, 0xb3, 0x8c, 0xc6, 0x01, 0xf7, 0x1f, 0x2d, 0xb0, 0x87, 0xf4, 0x05, 0x31, 0x4e, 0x4c, 0x9a, 0x0b, 0xf2, 0x1b, 0xc1, 0x4c, 0x20, 0xaf, 0x62, 0xee, 0x28, 0xdb, 0xf4, 0x35, 0x02, 0xbd, 0xb7, 0xa3, 0x55, 0xfd, 0xa5, 0x69, 0x7c, 0x33, 0xf6, 0xd0, 0xe1, 0xea, 0x8a, 0x70, 0x8a, 0x10, 0x18, 0x62, 0xe6, 0x90, 0xda, 0xc2, 0x53, 0x10, 0xb7, 0x66, 0xa5, 0xbd, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x85, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x39, 0xd1, 0x00, 0x0f, 0x53, 0xfb, 0xc4, 0xde, 0xce, 0x3d, 0x96, 0x37, 0xe1, 0x83, 0xac, 0x36, 0xa3, 0x8d, 0x67, 0xcd, 0x14, 0xab, 0x9c, 0x79, 0xa3, 0x07, 0x77, 0xb2, 0x72, 0x2d, 0xb6, 0x5f, 0x6d, 0x0e, 0x0b, 0x35, 0xf1, 0xf5, 0x2a, 0xdd, 0x61, 0x9c, 0xc1, 0x50, 0x86, 0xca, 0x69, 0xe3, 0x07, 0x0c, 0x2d, 0x1c, 0x1d, 0xc4, 0x73, 0x31, 0x5d, 0x23, 0xb1, 0xa6, 0xd8, 0x6c, 0x82, 0xd2, 0xbe, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x86, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xa5, 0x94, 0xbd, 0x4c, 0xde, 0x74, 0x6f, 0xc3, 0x59, 0x8f, 0x9e, 0xc0, 0x86, 0x25, 0x76, 0x19, 0x0f, 0x71, 0x34, 0x8a, 0x02, 0x7f, 0x46, 0x26, 0x1d, 0x1e, 0x04, 0xbc, 0x84, 0xf8, 0x3e, 0x5b, 0xa4, 0x39, 0x42, 0x88, 0x6e, 0xe1, 0xce, 0x5e, 0xf6, 0x26, 0xee, 0x17, 0x55, 0x8c, 0x2a, 0x7a, 0x06, 0xa2, 0xc2, 0xd5, 0xd5, 0xfd, 0x33, 0x94, 0xff, 0xdd, 0xb3, 0x31, 0xd2, 0x32, 0x17, 0x7e, 0xbe, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x04, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x87, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x4e, 0x2d, 0x5c, 0x03, 0x99, 0xeb, 0xc5, 0xc5, 0x32, 0x2f, 0x88, 0xcd, 0x10, 0x14, 0x14, 0x51, 0xee, 0x5a, 0x57, 0x52, 0x2b, 0x8a, 0xb3, 0x60, 0x36, 0xd2, 0x0d, 0x29, 0xe3, 0x8c, 0xb3, 0x18, 0x62, 0x67, 0x4f, 0x09, 0xe5, 0xae, 0xe7, 0x95, 0x6e, 0xe0, 0x9e, 0x34, 0x6e, 0x8b, 0x3e, 0xdb, 0x1d, 0x81, 0x8d, 0x08, 0xa0, 0xb2, 0x46, 0x61, 0xe3, 0xbf, 0x56, 0x44, 0xa4, 0x28, 0x1d, 0xa9, 0xbe, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x88, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x88, 0x90, 0x0a, 0x6b, 0xf9, 0xbd, 0x6a, 0x46, 0x1d, 0x06, 0x5e, 0xeb, 0x99, 0xad, 0x9d, 0xde, 0x56, 0x49, 0x52, 0xce, 0xc1, 0xfe, 0x60, 0xe4, 0xbe, 0xa6, 0xd8, 0x40, 0x28, 0x61, 0xad, 0x7d, 0x7b, 0x70, 0xbc, 0x1a, 0xd5, 0xe7, 0x63, 0x5d, 0x58, 0x38, 0x7e, 0x0b, 0xe8, 0xdd, 0x25, 0x73, 0x4a, 0xec, 0x64, 0x42, 0x43, 0x46, 0x03, 0x81, 0xea, 0x1b, 0x03, 0x37, 0x85, 0xad, 0x9f, 0x12, 0xbe, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x04, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x89, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x52, 0x81, 0x04, 0x15, 0x0f, 0x16, 0xfb, 0x36, 0xa4, 0xe6, 0xbb, 0x8c, 0x4d, 0x60, 0x16, 0xd8, 0x56, 0xe5, 0x78, 0xca, 0xd9, 0xc5, 0x6a, 0xc2, 0x2f, 0x85, 0xc0, 0xf1, 0xfd, 0xda, 0x9c, 0x1c, 0x71, 0x8d, 0xd0, 0x79, 0xb4, 0xd6, 0xa3, 0xc6, 0x06, 0xae, 0x1e, 0x1d, 0x15, 0x43, 0x83, 0xed, 0x6f, 0x81, 0x7e, 0xbe, 0x20, 0xe3, 0xb9, 0x60, 0xf5, 0xea, 0xfe, 0x77, 0x00, 0xd6, 0x82, 0xb8, 0xbe, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x8a, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x5e, 0xff, 0xbb, 0xe5, 0xe9, 0x51, 0x35, 0xf6, 0xe9, 0x28, 0x40, 0xb4, 0xd8, 0x2f, 0x67, 0xd2, 0x8c, 0x8a, 0x5c, 0xce, 0x1d, 0x05, 0x48, 0x4d, 0x17, 0xf1, 0x73, 0xf2, 0xce, 0x6a, 0xf7, 0x76, 0x21, 0xf1, 0x28, 0x76, 0x19, 0x61, 0x89, 0x0d, 0xcf, 0x6b, 0xd1, 0xa8, 0x0e, 0x59, 0x17, 0xa3, 0x63, 0x82, 0x68, 0xdb, 0x76, 0x5f, 0xbb, 0x62, 0xf1, 0xfd, 0xd0, 0xfa, 0x16, 0xfe, 0xf9, 0x8b, 0xbe, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x8b, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0x28, 0x14, 0x8a, 0x9f, 0x61, 0xd6, 0x29, 0x72, 0x95, 0xc1, 0x22, 0x6f, 0x87, 0x68, 0xba, 0x16, 0x02, 0x3a, 0x99, 0xf0, 0x9f, 0x4a, 0x95, 0x4c, 0x54, 0x23, 0xf3, 0xcb, 0xde, 0xa4, 0x5d, 0x28, 0x18, 0xf9, 0xb1, 0x0a, 0x85, 0x9c, 0x93, 0x89, 0x77, 0xe0, 0x77, 0x0c, 0x9e, 0xc1, 0xf4, 0xa7, 0xbc, 0x8d, 0xdd, 0x59, 0x67, 0xd7, 0xb6, 0xe1, 0x6a, 0x2c, 0x47, 0xf8, 0x62, 0x11, 0xc5, 0xd3, 0xbf, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x8c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xf7, 0xba, 0x22, 0xc8, 0x01, 0xcc, 0x57, 0x27, 0x4a, 0xec, 0x68, 0xc1, 0xa1, 0x56, 0xc1, 0x4d, 0x2b, 0x0e, 0x15, 0x8a, 0xad, 0x72, 0x3c, 0x51, 0x32, 0x2e, 0xa6, 0xa3, 0xbd, 0x64, 0x60, 0x5b, 0x13, 0x6c, 0x0a, 0x30, 0xa4, 0xb8, 0xd8, 0xae, 0x9f, 0xe0, 0x1b, 0x8d, 0x91, 0x9e, 0xca, 0xc7, 0xf4, 0x02, 0xe2, 0xf8, 0x0c, 0x1e, 0x8b, 0xc8, 0x10, 0xc6, 0xac, 0x0b, 0xd9, 0x60, 0x79, 0xd9, 0xbf, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x8d, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xd3, 0x06, 0x9e, 0xc8, 0xd0, 0x92, 0xfe, 0x17, 0x1f, 0xe9, 0xb7, 0x94, 0x95, 0xe8, 0xe7, 0xf2, 0x4d, 0xb5, 0xa4, 0x3e, 0x8e, 0x83, 0x05, 0xdc, 0x07, 0xf9, 0x96, 0xd1, 0xb1, 0xce, 0x65, 0x6d, 0x6b, 0x79, 0x59, 0x7c, 0xb0, 0xa1, 0xd8, 0x5c, 0xae, 0xd7, 0x16, 0x4c, 0x87, 0x6f, 0x3e, 0xc6, 0x75, 0x19, 0xc1, 0xa7, 0xfd, 0x2a, 0x49, 0x65, 0x30, 0x8e, 0x27, 0x26, 0x8c, 0xdd, 0x61, 0x67, 0xbf, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x8e, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x20, 0xee, 0xf7, 0x22, 0x72, 0xa0, 0xbb, 0x5c, 0xe0, 0x52, 0x8e, 0x10, 0xc2, 0x90, 0x24, 0x58, 0x54, 0xe5, 0x0c, 0x78, 0x90, 0x01, 0xac, 0x16, 0x09, 0x62, 0x2e, 0x8f, 0x64, 0x88, 0xac, 0xe5, 0x37, 0x37, 0x48, 0xc2, 0x84, 0x19, 0x44, 0x2c, 0x3e, 0x60, 0x38, 0x3f, 0x1f, 0xc1, 0x4e, 0x54, 0xd1, 0xc6, 0x81, 0xc6, 0x68, 0x15, 0x41, 0xa6, 0x8c, 0x3e, 0x36, 0x1f, 0xbc, 0x2f, 0xc5, 0x23, 0xcd, 0xbf, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x8f, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x68, 0x96, 0x59, 0x2a, 0x3e, 0xa4, 0xdb, 0xf8, 0xc1, 0x9e, 0x99, 0x98, 0xbe, 0x4f, 0xfa, 0x03, 0x82, 0x79, 0x43, 0x67, 0x9a, 0x42, 0x04, 0x71, 0x21, 0x20, 0xe3, 0x35, 0x9f, 0xda, 0xd2, 0x5c, 0x96, 0x14, 0x01, 0x9e, 0xa5, 0xdd, 0x11, 0xc3, 0xd3, 0x84, 0x22, 0xf8, 0xda, 0x66, 0x63, 0x1f, 0xed, 0x65, 0x31, 0xef, 0x5f, 0xcc, 0xe9, 0x27, 0xd8, 0x1e, 0xa3, 0x45, 0xb1, 0xfc, 0x67, 0x9b, 0xbf, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x90, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x52, 0x3c, 0x6e, 0xf8, 0xcf, 0xf4, 0x79, 0x60, 0x8a, 0x46, 0x7a, 0x02, 0xbc, 0xa0, 0x97, 0xb2, 0x96, 0x16, 0x79, 0xf3, 0xde, 0x0c, 0xdf, 0xc5, 0x72, 0x28, 0xfd, 0x95, 0xf4, 0xc0, 0x34, 0x01, 0xfd, 0x0a, 0xe1, 0x18, 0x18, 0x44, 0xf2, 0xdc, 0x4b, 0x81, 0xfd, 0x08, 0x66, 0xf0, 0x72, 0xa9, 0x7b, 0xce, 0x11, 0xa7, 0x72, 0x2a, 0x2a, 0x1f, 0xff, 0x55, 0x7a, 0xbd, 0x06, 0xa3, 0x61, 0x51, 0xbf, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x91, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x12, 0xac, 0x3b, 0xe4, 0x23, 0x09, 0xdd, 0x4f, 0xbf, 0xcc, 0x02, 0xf2, 0x07, 0xb6, 0xd5, 0x95, 0x65, 0x61, 0xa0, 0x9a, 0xeb, 0x4d, 0x98, 0x2a, 0x22, 0x20, 0x2f, 0x05, 0x2a, 0x96, 0x49, 0x4f, 0xbd, 0xc9, 0x72, 0xda, 0xa8, 0x95, 0xaf, 0x0e, 0x66, 0x2a, 0xc3, 0x05, 0x83, 0xa3, 0x5a, 0x82, 0xf6, 0x9f, 0x58, 0x4d, 0x9e, 0xe6, 0x65, 0xe7, 0xae, 0x77, 0x2e, 0x3c, 0x78, 0x55, 0x77, 0xdc, 0xc0, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x92, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x3a, 0x36, 0x61, 0x55, 0x34, 0x5a, 0xa1, 0xce, 0xf4, 0x4a, 0x58, 0x12, 0xce, 0x6b, 0x2f, 0xf9, 0xc1, 0x16, 0xfc, 0x23, 0x11, 0x0e, 0xa7, 0x71, 0xb9, 0x21, 0x7b, 0xf2, 0xbb, 0x75, 0xb2, 0x43, 0xc9, 0xfc, 0x73, 0xb6, 0x5c, 0xa6, 0xaf, 0xea, 0xba, 0xd3, 0x23, 0xd6, 0x2e, 0x01, 0xd2, 0x06, 0x81, 0x14, 0x38, 0xb3, 0x81, 0x3c, 0xf3, 0xd7, 0xd7, 0x4f, 0x00, 0xaa, 0xd7, 0xf6, 0x96, 0xdc, 0xc0, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x93, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xaf, 0xc5, 0x14, 0x22, 0x8a, 0x27, 0x54, 0x73, 0xb1, 0x90, 0x11, 0x36, 0x64, 0x49, 0x4a, 0x28, 0x81, 0x3a, 0xae, 0xb6, 0x66, 0xd7, 0x5c, 0xa0, 0x24, 0xd3, 0x5a, 0x07, 0xe1, 0x1f, 0x0b, 0x61, 0x50, 0xe6, 0x7c, 0x4a, 0xbb, 0xf2, 0xb3, 0x1e, 0xd6, 0xbe, 0x99, 0x4e, 0xe9, 0x51, 0xa5, 0xd8, 0x5f, 0xe7, 0x49, 0x60, 0x4b, 0x48, 0x21, 0x5b, 0x13, 0x75, 0x42, 0xc7, 0x73, 0x40, 0xfd, 0x5b, 0xc0, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x05, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x94, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xca, 0x9c, 0xd2, 0xfe, 0xa2, 0x55, 0x6b, 0x65, 0xb1, 0x6f, 0x8a, 0x3d, 0xc0, 0xdf, 0x73, 0xf0, 0xae, 0xdf, 0xe3, 0xe9, 0x41, 0x8c, 0x1d, 0xa9, 0x93, 0xe0, 0x7a, 0x05, 0xb9, 0x4b, 0x9b, 0x59, 0xad, 0x94, 0xef, 0xec, 0x2d, 0xdb, 0xf4, 0x29, 0x4b, 0x64, 0x90, 0x20, 0xf9, 0xcb, 0x94, 0x35, 0x4c, 0x58, 0x9f, 0x52, 0x62, 0x9a, 0xa9, 0x68, 0x70, 0xe4, 0xe8, 0xf0, 0x35, 0xf2, 0xe1, 0x3e, 0xc0, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x95, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x78, 0x2c, 0xa7, 0x55, 0x4e, 0x8c, 0x8d, 0x7a, 0x68, 0xec, 0x7c, 0x43, 0x4c, 0xe4, 0x1c, 0xf6, 0x23, 0x17, 0xb3, 0x92, 0x86, 0x2f, 0x8d, 0x63, 0x59, 0x47, 0x5d, 0x2f, 0x76, 0x36, 0xf0, 0x2d, 0x59, 0x57, 0x02, 0x8a, 0x93, 0xc2, 0xf7, 0x83, 0x43, 0xa4, 0x08, 0xb0, 0x87, 0x80, 0xa1, 0xa1, 0x97, 0x27, 0x34, 0xf3, 0xc6, 0x38, 0xf4, 0x13, 0xab, 0x11, 0x8e, 0x50, 0x60, 0x57, 0xc1, 0x76, 0xc0, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x96, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xf3, 0xe0, 0xa0, 0xf9, 0x82, 0x74, 0x25, 0x0e, 0x5c, 0x5a, 0x56, 0xad, 0xa4, 0x9b, 0xb2, 0x94, 0x01, 0x4c, 0x42, 0xf4, 0x02, 0xf6, 0xa2, 0xa4, 0x3b, 0x70, 0xd4, 0xfc, 0xd2, 0xa1, 0x04, 0x7d, 0x78, 0xab, 0xb1, 0xf5, 0x3c, 0x71, 0x3c, 0xd9, 0xd7, 0xb8, 0x82, 0xd9, 0x0d, 0xa4, 0xc5, 0x39, 0x0a, 0x52, 0xc7, 0x61, 0x00, 0x69, 0x1c, 0xb9, 0x34, 0xd7, 0x0c, 0x26, 0x8d, 0x0f, 0x64, 0x08, 0xc0, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x97, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xbf, 0x1e, 0x29, 0x25, 0xae, 0x12, 0x4d, 0xe8, 0x80, 0xbd, 0xea, 0xdb, 0xe4, 0xf1, 0x18, 0x5e, 0x2e, 0xfa, 0x1a, 0x26, 0x0f, 0xdc, 0x03, 0x57, 0x39, 0xed, 0xb6, 0xec, 0xcf, 0x76, 0x5a, 0x3c, 0x55, 0x9f, 0x1f, 0x38, 0xc1, 0x85, 0xec, 0x86, 0xde, 0xc0, 0x65, 0xa5, 0x65, 0xa5, 0xbf, 0xe3, 0x81, 0x0a, 0xa5, 0x24, 0x7f, 0xb1, 0x01, 0xf3, 0x2e, 0x19, 0xcb, 0x89, 0x35, 0xc6, 0x1e, 0x31, 0xc1, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x98, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xf2, 0xb1, 0xce, 0xae, 0x06, 0xde, 0xd5, 0x6e, 0x1a, 0x11, 0x11, 0x96, 0x0f, 0xdb, 0x03, 0xc6, 0x52, 0x71, 0xcd, 0x43, 0xcc, 0x45, 0x7e, 0x5f, 0x57, 0xab, 0x3f, 0x42, 0xf2, 0x3d, 0x72, 0x1e, 0xb7, 0xbd, 0x2c, 0xf8, 0x1b, 0x97, 0x14, 0x7a, 0x11, 0x2f, 0xbf, 0x47, 0x30, 0x0d, 0xf0, 0xa0, 0x13, 0xfe, 0x55, 0x8d, 0x0c, 0x26, 0x00, 0xaa, 0xe7, 0x1d, 0xb8, 0xe3, 0x9e, 0xc4, 0xa4, 0x78, 0xc1, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x99, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xcb, 0xd7, 0xbf, 0xd6, 0x45, 0x00, 0x22, 0x97, 0x1e, 0x58, 0x5d, 0x82, 0xc2, 0x3d, 0x23, 0x98, 0x22, 0xb4, 0xbd, 0x3d, 0xa3, 0x90, 0x69, 0x28, 0xab, 0x19, 0xb9, 0xf4, 0x4e, 0x5d, 0x1b, 0x42, 0xb7, 0xa7, 0xce, 0xa5, 0x8c, 0xb4, 0xb6, 0x33, 0x01, 0xe3, 0xbd, 0x15, 0xa9, 0xd5, 0xd5, 0x8e, 0xeb, 0x7f, 0xba, 0x20, 0xa4, 0x83, 0x23, 0xb0, 0xd9, 0x94, 0x5c, 0xc6, 0x83, 0xfe, 0x88, 0x74, 0xc1, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x9a, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x9e, 0x52, 0x16, 0x12, 0x72, 0xef, 0xae, 0xde, 0x15, 0x03, 0x98, 0x77, 0x17, 0xd6, 0xbf, 0xac, 0xd6, 0x59, 0x4d, 0x22, 0x76, 0x68, 0x3d, 0x4c, 0x09, 0x96, 0x26, 0xe9, 0x63, 0x45, 0x53, 0x20, 0xbf, 0xeb, 0xf0, 0xb2, 0x33, 0x0e, 0xc7, 0x60, 0xe0, 0x21, 0x60, 0x57, 0x2e, 0x43, 0x60, 0x3f, 0x1e, 0x5e, 0x69, 0xd5, 0x2a, 0xf9, 0x60, 0x79, 0x2e, 0xb5, 0xa4, 0xed, 0x4a, 0x9b, 0xc9, 0x77, 0xc1, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x9b, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xc1, 0x03, 0x62, 0x8b, 0x91, 0x42, 0x3b, 0xf5, 0xdb, 0x4c, 0x91, 0x4a, 0xec, 0xdd, 0x3d, 0x4e, 0x2c, 0x48, 0xfb, 0x5c, 0xb9, 0x1e, 0xbf, 0x0c, 0xd7, 0x08, 0xef, 0x88, 0xc8, 0x8c, 0xc3, 0x71, 0xf8, 0x1c, 0xd2, 0xe6, 0xfe, 0xdf, 0x8a, 0x37, 0xb6, 0x90, 0xc5, 0x82, 0x1a, 0x11, 0xc8, 0xd0, 0x3e, 0xf2, 0x78, 0x07, 0xa0, 0x51, 0xf5, 0x88, 0x9b, 0xc9, 0x56, 0x44, 0x68, 0xbb, 0x30, 0xab, 0xc1, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x9c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x1f, 0x4d, 0xbf, 0x90, 0x1f, 0x4f, 0x9d, 0x92, 0x6b, 0xe4, 0x45, 0xa1, 0xf6, 0x95, 0xed, 0x3f, 0x98, 0x48, 0xd5, 0x9b, 0x35, 0xc7, 0xc5, 0x88, 0x32, 0xee, 0x5e, 0xf4, 0x94, 0xc2, 0x0d, 0x12, 0xa3, 0xbe, 0x96, 0xb2, 0x75, 0xa3, 0x38, 0xa7, 0x54, 0x50, 0x6c, 0x30, 0x65, 0xe5, 0xcb, 0x44, 0xf4, 0xfd, 0x81, 0x1d, 0x2c, 0xfd, 0x27, 0x13, 0xca, 0xd3, 0x9a, 0x91, 0x10, 0x66, 0x6d, 0xc8, 0xc1, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x9d, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xf9, 0x28, 0xd5, 0xd5, 0x38, 0x5b, 0xbc, 0x2d, 0xfb, 0x5d, 0x47, 0xdf, 0xa2, 0x73, 0x98, 0x85, 0x2d, 0x3c, 0x94, 0xc4, 0x4f, 0x9a, 0xa7, 0x45, 0x0c, 0x8f, 0x18, 0x31, 0xf6, 0xbb, 0x85, 0x1b, 0x25, 0xcb, 0x21, 0x8e, 0xea, 0xdd, 0xed, 0x20, 0x1e, 0x0c, 0x24, 0xec, 0x32, 0x53, 0xd7, 0x6c, 0x9b, 0x2b, 0x1e, 0x2d, 0xb5, 0x88, 0x2f, 0x6f, 0x3c, 0x14, 0xe7, 0xe8, 0x46, 0xee, 0x97, 0x56, 0xc2, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x9e, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x52, 0x00, 0xb0, 0x56, 0x81, 0x30, 0xdf, 0x45, 0xb7, 0x55, 0x78, 0x65, 0xde, 0x19, 0x51, 0xb9, 0xba, 0x36, 0x2d, 0x3a, 0xab, 0xd8, 0xdc, 0x05, 0xdd, 0xe2, 0x4d, 0xf2, 0x70, 0xa5, 0xd7, 0x49, 0x07, 0x6c, 0xaa, 0x65, 0x57, 0xea, 0xa0, 0x95, 0x7a, 0x4b, 0xd2, 0x6f, 0xb0, 0x95, 0xf2, 0xa2, 0x49, 0x53, 0xf0, 0x50, 0x43, 0x5d, 0x76, 0x22, 0x5c, 0xe8, 0xaa, 0xc8, 0x30, 0x70, 0x4f, 0xe5, 0xc2, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0x9f, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x24, 0x12, 0xfe, 0x12, 0xa8, 0xb1, 0x84, 0x0a, 0x60, 0x3a, 0x75, 0xb3, 0x7f, 0xdd, 0x99, 0x3c, 0xb4, 0x28, 0xce, 0xf5, 0xb8, 0x0b, 0xbe, 0xb4, 0x3f, 0x6f, 0x17, 0x08, 0xbc, 0xf2, 0x72, 0x28, 0xd1, 0xff, 0x6c, 0x32, 0x4e, 0x38, 0xc5, 0x91, 0xcd, 0xce, 0x25, 0x12, 0x9a, 0xbd, 0xf3, 0xaf, 0xf8, 0x10, 0x7b, 0x29, 0x77, 0xc6, 0x85, 0x7c, 0xfa, 0x41, 0x56, 0x68, 0x5e, 0xa4, 0x09, 0x6a, 0xc2, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xa0, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xed, 0x74, 0x3e, 0x95, 0x3e, 0x5b, 0x7d, 0xd2, 0xdb, 0xaa, 0x0c, 0xbb, 0x66, 0xa0, 0x52, 0x2a, 0x82, 0xd9, 0x5b, 0xa2, 0xff, 0x25, 0xa1, 0x06, 0xb0, 0xe0, 0xce, 0xa9, 0x46, 0x7a, 0xc3, 0x19, 0xfb, 0xc6, 0x39, 0xf5, 0x97, 0x3a, 0xea, 0xf2, 0x8b, 0xaa, 0x74, 0x6a, 0x98, 0x42, 0xce, 0xa5, 0x3b, 0xa8, 0x56, 0xf6, 0x1c, 0xd3, 0xf8, 0xe1, 0x5b, 0xc8, 0x77, 0xc7, 0xd2, 0xe6, 0xbd, 0x54, 0xc2, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xa1, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xc0, 0x47, 0x00, 0x68, 0xec, 0x5c, 0x8b, 0x71, 0x47, 0xf3, 0x80, 0x56, 0xf2, 0xb8, 0x61, 0x23, 0xcd, 0x8d, 0xfd, 0x4e, 0x2a, 0x31, 0x84, 0x7d, 0xee, 0xd9, 0x8e, 0x61, 0x46, 0x96, 0x0d, 0x5b, 0x97, 0xa8, 0xde, 0x23, 0x54, 0x3b, 0x19, 0x9d, 0x5d, 0x41, 0xa2, 0x13, 0xfa, 0x2e, 0x72, 0x07, 0xf1, 0x3c, 0x6b, 0x41, 0xee, 0x81, 0x3e, 0xd7, 0xc4, 0x92, 0x3e, 0x6f, 0x9d, 0x18, 0xae, 0xff, 0xc2, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xa2, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xbb, 0x7e, 0x92, 0x1b, 0xa0, 0x7b, 0x03, 0x3b, 0x30, 0x16, 0xa5, 0x9f, 0x02, 0x31, 0xfd, 0xb8, 0x67, 0x05, 0x5c, 0x80, 0xa9, 0xa6, 0x4f, 0x32, 0xc0, 0x71, 0xff, 0x16, 0x06, 0xe5, 0x9e, 0x43, 0x89, 0x76, 0x9b, 0x2d, 0x99, 0xc1, 0x3d, 0x9e, 0xcc, 0x4d, 0xee, 0x5a, 0x2b, 0x52, 0x6a, 0x5f, 0x7e, 0xc8, 0xad, 0xcb, 0x57, 0xb9, 0x31, 0x94, 0xb2, 0x4b, 0xd0, 0xae, 0x03, 0x02, 0xdf, 0xe0, 0xc2, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xa3, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x26, 0xa1, 0xfc, 0x16, 0xd1, 0x83, 0x31, 0x9d, 0x97, 0xd9, 0x4c, 0xd2, 0xa7, 0xd0, 0x8e, 0x72, 0x06, 0x80, 0xd1, 0xb8, 0x5e, 0xfa, 0x2a, 0x1f, 0x17, 0xba, 0x27, 0x68, 0xb4, 0xd4, 0xa7, 0x4b, 0x08, 0xf1, 0xae, 0x61, 0xc9, 0xe6, 0x9a, 0x6c, 0xa2, 0xc7, 0xbd, 0xab, 0x9b, 0xce, 0x0d, 0xd6, 0x2f, 0xb7, 0x91, 0x0e, 0xbf, 0x9a, 0xfb, 0x4d, 0x0a, 0x75, 0xa2, 0xe5, 0xca, 0x76, 0x49, 0x78, 0xc3, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xa4, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x19, 0x1d, 0x90, 0x4e, 0xab, 0x26, 0x3d, 0xb4, 0xf4, 0x14, 0x36, 0xd6, 0xfe, 0x04, 0x2e, 0x19, 0x74, 0x8d, 0x34, 0x8b, 0xb6, 0x07, 0xa5, 0x54, 0x08, 0xf8, 0x66, 0x6b, 0x2f, 0xef, 0x6f, 0x48, 0x7b, 0x8a, 0x6b, 0xad, 0xdc, 0x9a, 0xbe, 0x0a, 0x4b, 0x21, 0x58, 0xdb, 0xb8, 0xcf, 0xa1, 0xbc, 0x82, 0x60, 0xf1, 0xef, 0xb1, 0xea, 0x8d, 0x1a, 0xea, 0x5c, 0xca, 0xaf, 0x96, 0x42, 0x0c, 0xe7, 0xc3, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xa5, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x31, 0x92, 0xc0, 0x14, 0xb9, 0xf2, 0xc8, 0x58, 0x46, 0x16, 0x75, 0x98, 0x8e, 0x01, 0xa7, 0xdf, 0xe9, 0x02, 0x40, 0x82, 0x57, 0xad, 0x8d, 0xb9, 0x46, 0x7a, 0xd5, 0x49, 0x4b, 0x0f, 0x80, 0x32, 0x7a, 0xac, 0x98, 0x08, 0x21, 0xff, 0x36, 0x2f, 0xb5, 0x9c, 0xca, 0x12, 0x2b, 0xa2, 0x5d, 0x35, 0xbc, 0x82, 0x5e, 0x61, 0xf2, 0x2c, 0x09, 0xfa, 0x6b, 0x64, 0xf5, 0x1d, 0x89, 0x11, 0x5c, 0x6a, 0xc3, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xa6, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xda, 0x30, 0x9b, 0x9a, 0x62, 0x3c, 0x52, 0x5c, 0x5e, 0x01, 0x08, 0x8a, 0xbc, 0xab, 0xf0, 0xea, 0xe3, 0x87, 0xa7, 0x06, 0x31, 0xd6, 0x9d, 0xdd, 0x2e, 0x2c, 0x1e, 0xaa, 0x36, 0x6e, 0x7d, 0x08, 0xe1, 0xa0, 0x04, 0x4b, 0xa6, 0x16, 0xc9, 0xce, 0xac, 0xc1, 0xf3, 0x9c, 0x6e, 0x61, 0xb1, 0x4b, 0xb4, 0x3a, 0x87, 0xbe, 0x69, 0x88, 0x0f, 0x63, 0x9f, 0x67, 0xb5, 0xa7, 0x81, 0x2d, 0x67, 0x48, 0xc3, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xa7, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xc3, 0xfc, 0x84, 0x1e, 0x45, 0x5c, 0xb7, 0xab, 0x8e, 0x83, 0xc1, 0xb4, 0x5a, 0x92, 0x30, 0x69, 0x2f, 0xc6, 0xbf, 0x54, 0x21, 0x9e, 0x39, 0xcc, 0x32, 0xbb, 0xcf, 0xe2, 0x64, 0xf2, 0x1f, 0x19, 0x5e, 0xac, 0xb3, 0xbb, 0xfc, 0x83, 0xff, 0x7a, 0x0c, 0xec, 0x7c, 0x88, 0xc3, 0x7e, 0x9d, 0xa4, 0x47, 0x2a, 0x42, 0x81, 0x96, 0x75, 0x59, 0xa8, 0x4a, 0xe1, 0xfe, 0x97, 0x7c, 0x63, 0x94, 0x65, 0xc3, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xa8, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xca, 0xfc, 0x62, 0x7a, 0xeb, 0x71, 0x4f, 0x3e, 0x3c, 0xbe, 0xf6, 0x5c, 0x5b, 0x15, 0x9a, 0xed, 0x54, 0x58, 0x50, 0xb9, 0xda, 0x4e, 0xf9, 0x9d, 0x7f, 0x03, 0x85, 0xda, 0x2e, 0x91, 0x3f, 0x2b, 0xc5, 0xc1, 0x7a, 0xab, 0x7d, 0x0a, 0x0b, 0xd0, 0x32, 0x4b, 0xf7, 0xe9, 0xe2, 0xef, 0x88, 0xc6, 0x36, 0x41, 0xd6, 0x20, 0x84, 0x6f, 0xfb, 0x18, 0xcc, 0x8e, 0x0f, 0x92, 0x50, 0x28, 0x45, 0x1e, 0xc3, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xa9, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xef, 0x97, 0x1a, 0x00, 0x9d, 0x01, 0x50, 0x9d, 0xd1, 0x52, 0xbe, 0xa0, 0x00, 0x70, 0x51, 0x55, 0x9a, 0x58, 0xc3, 0x01, 0xe9, 0xc3, 0xdc, 0x63, 0x53, 0x5b, 0x94, 0x4a, 0x7d, 0xcc, 0x33, 0x0e, 0xec, 0x01, 0xb3, 0x22, 0xa6, 0xa7, 0xba, 0x13, 0x96, 0xe6, 0x10, 0xc9, 0xf4, 0xda, 0x69, 0x77, 0x94, 0x99, 0x32, 0x54, 0x63, 0xe1, 0x28, 0x82, 0x2d, 0xac, 0x6d, 0x80, 0xbb, 0x62, 0xb2, 0x68, 0xc4, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xaa, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x29, 0x7d, 0x2f, 0xbc, 0xc8, 0x4a, 0x9f, 0xb6, 0x1e, 0xff, 0xcf, 0x30, 0x56, 0x4b, 0x34, 0x8f, 0x2a, 0x51, 0xcb, 0x18, 0x6e, 0x0b, 0x1f, 0xfd, 0x50, 0x79, 0xe9, 0xc3, 0xbd, 0x19, 0x39, 0x56, 0x3f, 0x31, 0x4e, 0x6e, 0x6b, 0x92, 0xd1, 0xc7, 0x3e, 0xdb, 0x47, 0xb2, 0x1f, 0x80, 0x08, 0xaa, 0x22, 0x5c, 0x8d, 0x87, 0xf5, 0x93, 0x91, 0xd1, 0xbf, 0xd1, 0xf4, 0xac, 0xdc, 0xe6, 0xf5, 0x6c, 0xc4, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xab, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x22, 0xcf, 0xd9, 0xa1, 0x06, 0x8f, 0x86, 0x4e, 0xa0, 0xca, 0x15, 0xf4, 0xb6, 0x61, 0x08, 0x5d, 0x38, 0x34, 0x33, 0x20, 0x80, 0x76, 0xec, 0x04, 0xb6, 0xdf, 0x4f, 0xca, 0xd5, 0xce, 0x12, 0x4b, 0xf6, 0x48, 0xbe, 0x1e, 0xb0, 0x86, 0xbe, 0x6b, 0xef, 0x7f, 0xd6, 0x59, 0x11, 0xd9, 0x84, 0x9a, 0xcf, 0x56, 0xdd, 0x9c, 0xf2, 0x47, 0x98, 0xe1, 0x80, 0x54, 0xab, 0x20, 0x88, 0xe2, 0x7e, 0xab, 0xc4, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xac, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x97, 0x2f, 0x66, 0xa3, 0x42, 0xe8, 0xbd, 0x2e, 0x91, 0x2a, 0xa2, 0x80, 0x56, 0xa3, 0x94, 0xe5, 0xbf, 0x00, 0x51, 0x87, 0x00, 0x18, 0x63, 0xd8, 0x16, 0x7e, 0xa2, 0xc0, 0x59, 0x16, 0x4e, 0x2e, 0xa6, 0x4d, 0x06, 0x8a, 0x4a, 0x72, 0x43, 0x1c, 0xd9, 0x7f, 0xa1, 0x26, 0xbd, 0xdc, 0x9e, 0x3a, 0x6f, 0xc6, 0x26, 0x2e, 0x13, 0x1d, 0xf4, 0x73, 0x28, 0x15, 0x6b, 0xa5, 0xee, 0x2d, 0xc1, 0x18, 0xc4, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x06, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xad, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x89, 0x0d, 0xfc, 0xeb, 0x5d, 0x57, 0x3e, 0x6a, 0xfb, 0x97, 0xb8, 0xc9, 0x45, 0xa1, 0x9f, 0xd9, 0xb6, 0x60, 0x1b, 0x99, 0x2f, 0x80, 0x01, 0x57, 0x62, 0xa5, 0x28, 0xaf, 0x66, 0x26, 0xf8, 0x41, 0x1d, 0xe5, 0x7c, 0xbc, 0x0f, 0x26, 0x84, 0x8e, 0xc7, 0xc4, 0x54, 0x1a, 0x26, 0x3b, 0x23, 0x14, 0xa1, 0x87, 0x7d, 0xfa, 0xaf, 0x53, 0xa6, 0xa0, 0xab, 0x03, 0xab, 0x0a, 0xbe, 0x4f, 0xcf, 0x40, 0xc4, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xae, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xe5, 0x4b, 0x3b, 0x16, 0x5e, 0xf5, 0x24, 0x98, 0xf0, 0xd9, 0xaf, 0x57, 0x74, 0xa6, 0x88, 0x13, 0x89, 0x78, 0xef, 0xe7, 0x54, 0x80, 0xaa, 0x01, 0xce, 0x60, 0x6d, 0xec, 0x58, 0x76, 0xe2, 0x17, 0xc1, 0xc0, 0x51, 0xb9, 0xef, 0x4f, 0x7c, 0x23, 0x6a, 0x2d, 0x89, 0x2b, 0xf9, 0x8e, 0x10, 0x8f, 0x11, 0x93, 0xf7, 0xc6, 0x7e, 0x16, 0x3d, 0x74, 0x8a, 0x32, 0x1c, 0x5a, 0xc1, 0xd9, 0xd5, 0x54, 0xc4, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xaf, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xb8, 0x7c, 0xbc, 0xe4, 0x90, 0xf4, 0x6d, 0x37, 0x23, 0xf4, 0x98, 0xd4, 0x4d, 0xf0, 0x5c, 0x66, 0x13, 0xd4, 0x43, 0x22, 0xac, 0xab, 0x17, 0x40, 0xe0, 0x5a, 0x1d, 0x54, 0xbc, 0x2e, 0x0f, 0x44, 0x38, 0x80, 0x78, 0x38, 0x7e, 0x07, 0x8f, 0x1a, 0x0b, 0xe7, 0x31, 0x7c, 0x7f, 0xe0, 0x4d, 0x74, 0x39, 0x47, 0xc5, 0xf3, 0xf9, 0xe0, 0x60, 0x72, 0xa7, 0xa8, 0xf0, 0x1f, 0x01, 0x3e, 0x4e, 0x63, 0xc5, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xb0, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x89, 0xc4, 0xd7, 0xee, 0xe1, 0xaa, 0xca, 0x1d, 0x09, 0x1f, 0x31, 0xa4, 0xb4, 0x65, 0xa1, 0x6a, 0x45, 0x0b, 0xc9, 0x5f, 0x04, 0x3a, 0x92, 0x14, 0x67, 0x4f, 0x25, 0x64, 0xae, 0x04, 0x08, 0x64, 0x93, 0xe5, 0xc1, 0xd3, 0x0b, 0xdf, 0x99, 0x83, 0x45, 0xa6, 0xcc, 0xbd, 0x20, 0x20, 0x1f, 0x78, 0xde, 0xe8, 0x97, 0x2b, 0x43, 0x9b, 0x22, 0x8f, 0x02, 0xb5, 0x90, 0xae, 0x13, 0xb6, 0x6f, 0x98, 0xc5, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xb1, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xca, 0x6a, 0x1e, 0xbf, 0x54, 0xb1, 0xf6, 0x23, 0x13, 0xcb, 0x32, 0xe7, 0xaf, 0x2b, 0x64, 0x69, 0x13, 0x5d, 0x8d, 0xa9, 0x57, 0x71, 0x23, 0xb6, 0x2b, 0x33, 0x4e, 0xb1, 0xac, 0x8f, 0xb3, 0x20, 0x36, 0x7b, 0xcf, 0x29, 0xd7, 0x85, 0xbf, 0xed, 0xb2, 0xcc, 0x1f, 0xa0, 0x40, 0xc5, 0x93, 0x78, 0x3d, 0x35, 0xf7, 0xbc, 0xf6, 0xb7, 0x0a, 0x9d, 0x98, 0xce, 0xdd, 0xdf, 0xba, 0xa6, 0x1e, 0x8c, 0xc5, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xb2, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x4f, 0xe0, 0x71, 0xde, 0x37, 0x02, 0x5d, 0x58, 0x68, 0xca, 0xf9, 0x20, 0x76, 0x19, 0x86, 0xef, 0x08, 0x90, 0xa3, 0x89, 0x1e, 0x05, 0x3d, 0x54, 0x52, 0xb0, 0x85, 0x2f, 0x01, 0xbc, 0x7a, 0x5b, 0x2d, 0xbe, 0x8a, 0x30, 0xd7, 0xa8, 0x28, 0x5f, 0xf0, 0xe9, 0x9e, 0x3b, 0x72, 0x23, 0x77, 0x11, 0xfd, 0x04, 0x18, 0xd9, 0x5a, 0x44, 0x60, 0x0a, 0x4a, 0x5b, 0x78, 0xd8, 0xb5, 0xa6, 0x79, 0x8c, 0xc5, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xb3, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x64, 0x20, 0x04, 0xa6, 0x7b, 0x3c, 0x8f, 0xca, 0x45, 0x51, 0x66, 0x72, 0xd5, 0x9a, 0x14, 0x5e, 0x74, 0xf3, 0xc0, 0x26, 0x08, 0xb8, 0xda, 0x59, 0x98, 0xc2, 0x7c, 0x8f, 0x2b, 0x05, 0xb4, 0x3f, 0xb3, 0x96, 0x26, 0x26, 0x80, 0xea, 0xd3, 0x4a, 0x6b, 0xa6, 0xf5, 0xba, 0x19, 0xf6, 0x17, 0x60, 0x6b, 0x17, 0x01, 0x55, 0x71, 0x79, 0xc2, 0x1c, 0xfd, 0xb3, 0xe4, 0x1f, 0x09, 0x3e, 0x93, 0x43, 0xc5, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xb4, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xdf, 0xde, 0xf6, 0x1d, 0x55, 0x24, 0x22, 0xcc, 0x6d, 0xb6, 0xa3, 0x1c, 0xb3, 0x8c, 0x74, 0xef, 0xea, 0x16, 0x0c, 0xdc, 0x92, 0x69, 0x95, 0x46, 0x1f, 0x47, 0xfd, 0x52, 0xfa, 0xef, 0x3b, 0x22, 0xbb, 0xf9, 0xc5, 0x70, 0xef, 0xdf, 0x15, 0xb9, 0x0c, 0xd1, 0x76, 0x69, 0xc4, 0xa8, 0xdc, 0x95, 0x25, 0xee, 0x62, 0x42, 0x02, 0x59, 0x79, 0xaf, 0x18, 0xef, 0xa0, 0xbe, 0x7d, 0x03, 0xed, 0xc5, 0xc5, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xb5, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x61, 0x4d, 0xfa, 0xbf, 0xee, 0x3a, 0x6b, 0xc5, 0x0d, 0x77, 0x57, 0x48, 0xac, 0x67, 0x94, 0x72, 0xf0, 0xb1, 0xf7, 0x08, 0x81, 0x5f, 0xd1, 0x72, 0x85, 0x2b, 0xaf, 0x66, 0xb7, 0xa6, 0x4a, 0x41, 0x0e, 0xcb, 0x1a, 0xd6, 0x8c, 0xdd, 0x78, 0xf7, 0x24, 0x0b, 0x80, 0xd0, 0x15, 0xf9, 0x22, 0x41, 0x65, 0x60, 0xec, 0xa0, 0x40, 0x39, 0x85, 0x46, 0xa7, 0x4c, 0x33, 0x10, 0x6b, 0x27, 0xc7, 0x91, 0xc6, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xb6, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xd1, 0xf6, 0xca, 0x10, 0x19, 0x05, 0x78, 0xf7, 0xf7, 0x89, 0xb8, 0x78, 0x5f, 0xac, 0x04, 0x3d, 0xa1, 0xa0, 0x6a, 0xd8, 0x1e, 0x40, 0x55, 0x82, 0x2c, 0xf2, 0x0a, 0xbd, 0xac, 0x7b, 0xd6, 0x4f, 0xc5, 0x87, 0x4b, 0x18, 0x16, 0xbb, 0xcd, 0x03, 0x59, 0x54, 0x04, 0xfa, 0xaa, 0x17, 0x56, 0x42, 0x97, 0xbb, 0x17, 0xef, 0x68, 0xb8, 0x1f, 0xf2, 0x95, 0x33, 0xc6, 0x7d, 0x1b, 0x5c, 0x53, 0x46, 0xc6, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xb7, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xeb, 0x11, 0x8f, 0xc6, 0x56, 0xcc, 0xb1, 0x68, 0x53, 0x27, 0x45, 0x32, 0x56, 0x75, 0xf5, 0x77, 0xf3, 0x70, 0x65, 0x6e, 0xc3, 0x4e, 0x33, 0x03, 0x86, 0x40, 0x84, 0xd4, 0xcd, 0xc9, 0x71, 0x4b, 0x37, 0xc8, 0xb3, 0xa9, 0xd2, 0x54, 0x79, 0x35, 0xa6, 0x0a, 0x2f, 0x08, 0x2d, 0x5d, 0x66, 0x61, 0x77, 0x30, 0x5c, 0x98, 0x05, 0x69, 0x91, 0xdc, 0xed, 0xab, 0xd6, 0xce, 0x41, 0xa7, 0x5e, 0x42, 0xc6, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xb8, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x88, 0x11, 0x84, 0xd8, 0xfc, 0x09, 0x97, 0xd5, 0xe8, 0x7c, 0xd0, 0x69, 0xa1, 0x81, 0x2f, 0xfb, 0xd9, 0x38, 0xff, 0xd2, 0x39, 0x08, 0x85, 0xd1, 0x5e, 0x40, 0x86, 0x58, 0xe5, 0x01, 0xda, 0x59, 0x6a, 0xdc, 0x75, 0x3f, 0x17, 0xf3, 0xb1, 0xdd, 0x68, 0x17, 0xd1, 0xd5, 0x93, 0xb6, 0x19, 0x6e, 0x96, 0x96, 0xbf, 0xa9, 0x0d, 0x17, 0x9c, 0xd0, 0xd0, 0x50, 0xda, 0xd2, 0x53, 0x2d, 0x44, 0xad, 0xc6, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xb9, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x1a, 0xa4, 0x4b, 0x36, 0x3c, 0x58, 0x12, 0x4b, 0x22, 0xd5, 0x11, 0x78, 0xe7, 0x0b, 0x86, 0xf9, 0x76, 0xf8, 0xe9, 0x4a, 0x5f, 0xfe, 0x96, 0x96, 0x71, 0x50, 0x56, 0xe9, 0xb2, 0x0e, 0x0c, 0x49, 0x14, 0xd1, 0x4a, 0xc8, 0xda, 0x26, 0x25, 0xd3, 0xda, 0x07, 0x0b, 0xe3, 0xd2, 0x52, 0x21, 0x64, 0xf9, 0xe3, 0xf3, 0x45, 0x28, 0x52, 0x69, 0x55, 0xd7, 0x15, 0x65, 0xb5, 0xfa, 0x2a, 0x7b, 0xed, 0xc6, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xba, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xd5, 0xc8, 0x1f, 0x5d, 0x6b, 0x91, 0x88, 0xad, 0xc2, 0x02, 0x32, 0x7d, 0x5c, 0x27, 0x69, 0xf0, 0x0e, 0x6a, 0xaf, 0xdf, 0x01, 0xe6, 0x91, 0x0c, 0x67, 0x6e, 0x99, 0x43, 0x4d, 0x1c, 0x41, 0x34, 0x49, 0xea, 0x0d, 0x2e, 0xf2, 0x77, 0x5f, 0x6a, 0xe5, 0xf5, 0x67, 0x3b, 0x9d, 0xb0, 0x20, 0xe4, 0x4d, 0x41, 0x7e, 0x01, 0xad, 0x9a, 0x69, 0x1e, 0x10, 0x5f, 0x5c, 0x9a, 0xe2, 0xf7, 0x09, 0xb8, 0xc6, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xbb, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x55, 0xa4, 0x17, 0x6e, 0x66, 0xb3, 0xe6, 0x91, 0xce, 0xd8, 0x4c, 0x0d, 0x71, 0x84, 0xd2, 0x20, 0xa1, 0xfc, 0x7c, 0xf1, 0x78, 0x32, 0xa2, 0xed, 0x48, 0x92, 0xe8, 0x01, 0xc7, 0x13, 0x44, 0x54, 0x63, 0xeb, 0xb3, 0x61, 0x5a, 0x61, 0x13, 0xc2, 0xdd, 0xfd, 0x4e, 0x0f, 0x5b, 0x8f, 0xdc, 0xb2, 0xaa, 0xe9, 0x12, 0x56, 0x9d, 0x35, 0x30, 0xf9, 0x83, 0xf5, 0x79, 0x50, 0xbb, 0xb9, 0xca, 0x24, 0xc7, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xbc, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x13, 0xa5, 0x0d, 0x5e, 0x9a, 0x17, 0x07, 0x9b, 0x1b, 0xce, 0xdf, 0xb6, 0x42, 0x6b, 0xf7, 0xc1, 0x03, 0xcd, 0xf7, 0xac, 0x35, 0x3d, 0x19, 0x68, 0x82, 0xdf, 0xb0, 0xa0, 0xf7, 0xdc, 0xf2, 0x6d, 0x48, 0x41, 0x8e, 0x7e, 0xcc, 0xf5, 0x66, 0x33, 0x44, 0x56, 0x6a, 0xc2, 0x83, 0xe4, 0xaf, 0x41, 0xc7, 0x4f, 0x50, 0x3d, 0xd4, 0x20, 0x48, 0xe1, 0xa7, 0x31, 0xc3, 0xce, 0x73, 0xc8, 0x74, 0x85, 0xc7, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xbd, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x3d, 0xa9, 0x65, 0xbc, 0x08, 0xfb, 0xa5, 0x25, 0x71, 0x47, 0x35, 0x32, 0xc1, 0xef, 0x4c, 0xb1, 0x11, 0xe9, 0x34, 0x41, 0x45, 0xfd, 0x7a, 0x60, 0x65, 0xc9, 0x2d, 0x32, 0xc4, 0xe6, 0x90, 0x79, 0xc8, 0x8b, 0x8c, 0x63, 0xa7, 0xbd, 0x7e, 0xce, 0x34, 0x10, 0x22, 0x6c, 0xda, 0x39, 0xd0, 0xfb, 0x5d, 0xc4, 0xe1, 0xb4, 0xcb, 0x56, 0x09, 0x67, 0xf0, 0x3e, 0x12, 0xd7, 0xf1, 0x55, 0xaa, 0xfa, 0xc7, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xbe, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xc8, 0xcf, 0x32, 0xd3, 0x2c, 0xbc, 0x1e, 0x5f, 0xcb, 0x6c, 0x2b, 0x75, 0x52, 0x06, 0x18, 0xa4, 0x3d, 0xc7, 0x14, 0xa1, 0x67, 0x06, 0xd3, 0xa4, 0x8e, 0xc6, 0x8f, 0x56, 0xe8, 0xcc, 0x59, 0x3a, 0xdc, 0x15, 0xd4, 0xd1, 0x68, 0x05, 0x37, 0xdf, 0x08, 0xab, 0xcf, 0x0a, 0xc0, 0x86, 0x61, 0xfc, 0x7e, 0xcd, 0x0b, 0x92, 0x67, 0xf2, 0x07, 0xd7, 0x08, 0x5a, 0x95, 0x4a, 0x6c, 0xe2, 0xda, 0x8c, 0xc7, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xbf, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x04, 0xc9, 0x81, 0xc7, 0x49, 0xb4, 0xac, 0xa5, 0x74, 0xfb, 0xee, 0xba, 0x54, 0x5c, 0xeb, 0xc3, 0x0f, 0x91, 0xe2, 0xb8, 0xdf, 0x3c, 0xeb, 0x49, 0x46, 0x46, 0xb0, 0xec, 0xbf, 0x3e, 0xbb, 0x61, 0x0a, 0xfe, 0x1b, 0xfd, 0xd7, 0xea, 0x91, 0x10, 0x22, 0x0e, 0xb1, 0xf1, 0x02, 0xad, 0x69, 0x40, 0x7d, 0x6c, 0x44, 0x02, 0x6c, 0x4d, 0xd4, 0xbf, 0x92, 0x67, 0xd7, 0x30, 0xc1, 0x60, 0xd2, 0x88, 0xc7, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xc0, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xb0, 0xb0, 0x58, 0x77, 0x7d, 0xc4, 0x96, 0x67, 0x6c, 0xf9, 0x90, 0xbe, 0x01, 0x61, 0x17, 0xd9, 0x9f, 0xc5, 0xa9, 0x32, 0x26, 0xd5, 0x4b, 0x9b, 0x4f, 0x01, 0xbd, 0x08, 0xef, 0x32, 0x73, 0x6f, 0x70, 0x7f, 0x2d, 0x27, 0xe9, 0x38, 0x4a, 0xe4, 0x6a, 0x08, 0x95, 0x61, 0x85, 0xb5, 0xb0, 0x80, 0x91, 0x1b, 0x9e, 0xba, 0x89, 0xdf, 0xe4, 0x82, 0x60, 0x27, 0x6d, 0x09, 0xf9, 0x10, 0xc3, 0xfc, 0xc7, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xc1, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xea, 0x8c, 0xd2, 0x97, 0x4a, 0xa0, 0xac, 0x63, 0x60, 0xb9, 0x60, 0xe0, 0x89, 0xa6, 0x62, 0x3b, 0x7b, 0xdd, 0x41, 0x52, 0x43, 0x9d, 0x05, 0xc6, 0x3b, 0xfb, 0xa1, 0x59, 0x9b, 0x64, 0x01, 0x7d, 0x4d, 0x41, 0x73, 0xc3, 0xe1, 0x26, 0x68, 0x29, 0x7d, 0x23, 0xcf, 0x91, 0xd3, 0x14, 0x1e, 0xe0, 0x12, 0x92, 0x58, 0x0d, 0xfd, 0xd7, 0x0a, 0x2e, 0x6f, 0xa3, 0x0c, 0x47, 0x64, 0x00, 0x8f, 0x37, 0xc8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xc2, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xee, 0x8d, 0xb3, 0x36, 0xdc, 0x2b, 0xa9, 0xf8, 0x5b, 0xad, 0x14, 0x1b, 0x11, 0x5d, 0x9c, 0xe7, 0x29, 0xef, 0x0c, 0xf4, 0xe2, 0x74, 0xad, 0xbc, 0x88, 0x94, 0x7f, 0x35, 0x33, 0xe7, 0xca, 0x56, 0x9e, 0x6e, 0x65, 0xde, 0xa6, 0xc0, 0x9c, 0x9f, 0x5e, 0x3c, 0x8d, 0x09, 0x85, 0x50, 0x58, 0x8c, 0xda, 0x81, 0xf9, 0x2d, 0xc5, 0xd7, 0xec, 0x04, 0xfc, 0x99, 0x65, 0xd9, 0x7d, 0xd1, 0xac, 0x6b, 0xc8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xc3, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xa0, 0x6a, 0x5e, 0x0b, 0x84, 0xc8, 0xe7, 0x2a, 0x07, 0xff, 0x38, 0xdb, 0xfe, 0x03, 0xfb, 0x8e, 0x7c, 0xe1, 0xf1, 0x4f, 0x3f, 0x26, 0x32, 0xd4, 0xe1, 0x2f, 0x57, 0x3e, 0x6c, 0x61, 0xc7, 0x56, 0xa7, 0xe2, 0x1a, 0x86, 0x59, 0x26, 0xb8, 0xcd, 0xe1, 0x30, 0x5c, 0x83, 0xdf, 0xda, 0x2e, 0x7a, 0x01, 0x59, 0x1d, 0xae, 0x64, 0x2a, 0x44, 0x02, 0xd2, 0xd2, 0x98, 0x40, 0x63, 0x49, 0xf3, 0x9b, 0xc8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xc4, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xec, 0xce, 0xaf, 0xaf, 0x94, 0x79, 0x06, 0xcc, 0x86, 0xbb, 0xed, 0xb1, 0xb9, 0x55, 0x6a, 0xba, 0x9e, 0xfc, 0xf4, 0xf1, 0x2a, 0x19, 0x14, 0x14, 0x21, 0xc2, 0xcf, 0xa0, 0x30, 0xd5, 0xa1, 0x7a, 0xe1, 0xe2, 0x5e, 0x04, 0x6c, 0xf6, 0x9c, 0x4f, 0xb9, 0xee, 0xb1, 0xd0, 0x72, 0x89, 0xf4, 0x6f, 0x0c, 0xac, 0xdf, 0x13, 0x01, 0x61, 0x98, 0x50, 0xa3, 0xd6, 0x93, 0x93, 0x54, 0x76, 0xe8, 0x19, 0xc8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xc5, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x97, 0xe2, 0x7b, 0xf8, 0xd0, 0x14, 0x8c, 0x85, 0x1a, 0xd5, 0xc3, 0x40, 0x9a, 0x22, 0x2a, 0x74, 0x1d, 0xdc, 0xbc, 0x5c, 0x71, 0xf9, 0x7d, 0xf8, 0x73, 0x84, 0xc3, 0xd1, 0xe3, 0x16, 0xe4, 0x6e, 0x42, 0x70, 0x60, 0xa1, 0x3c, 0xd9, 0x1b, 0x94, 0xeb, 0x4b, 0xb2, 0x31, 0x7d, 0xb6, 0x44, 0x06, 0x65, 0x7a, 0xb2, 0x50, 0x78, 0x4a, 0x67, 0xfc, 0x78, 0x3c, 0x00, 0xa2, 0x4f, 0x3b, 0x6f, 0xab, 0xc8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xc6, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x98, 0xff, 0xf5, 0xfa, 0xb4, 0x95, 0x55, 0xcd, 0xa5, 0xda, 0x11, 0x3c, 0x67, 0x9f, 0x2d, 0xa0, 0x7c, 0xc7, 0xc5, 0x69, 0x60, 0x67, 0xc5, 0x3d, 0x84, 0xd7, 0xbc, 0xaa, 0x71, 0xa5, 0xcc, 0x35, 0x1c, 0xae, 0x4b, 0x9e, 0x2f, 0xd5, 0x90, 0x2a, 0x4e, 0x07, 0x12, 0xee, 0x59, 0xfd, 0x91, 0x8a, 0x38, 0x13, 0x55, 0x4e, 0xaa, 0x3a, 0xb0, 0x6e, 0x73, 0xc1, 0x89, 0xae, 0x6f, 0x22, 0xb9, 0x95, 0xc8, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xc7, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xa1, 0xa1, 0x2a, 0x3a, 0x01, 0x0a, 0x3f, 0x69, 0x12, 0x3a, 0x30, 0x42, 0x7c, 0xe8, 0x86, 0xf3, 0xd4, 0xca, 0x42, 0xf9, 0xfb, 0xf8, 0x20, 0xeb, 0xf6, 0xb0, 0x0c, 0x20, 0x89, 0xa0, 0xb3, 0x0e, 0xc5, 0x47, 0x10, 0x3a, 0xe3, 0xdc, 0x47, 0x0f, 0x3a, 0x8b, 0x99, 0x9e, 0xd7, 0x50, 0x68, 0xd1, 0x50, 0x75, 0x0a, 0xc0, 0xc5, 0x49, 0xf0, 0x92, 0xc5, 0x1c, 0x96, 0x89, 0xcb, 0x1b, 0xc1, 0xd2, 0xc9, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xc8, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xda, 0x26, 0x88, 0xef, 0x7d, 0x46, 0x6c, 0xed, 0xea, 0x6d, 0x37, 0x37, 0xaf, 0x58, 0xfa, 0x34, 0xde, 0x69, 0xd0, 0x22, 0xb5, 0xd1, 0xdc, 0x7b, 0xc0, 0xaa, 0xa2, 0x01, 0x12, 0xb4, 0x0a, 0x64, 0xa9, 0x9d, 0x65, 0xb6, 0x8f, 0x1c, 0x7f, 0x04, 0xef, 0xc0, 0x82, 0xa9, 0x8e, 0x14, 0x57, 0x6c, 0x01, 0x42, 0x75, 0x15, 0xcb, 0xaf, 0xc1, 0xf5, 0xc3, 0xd3, 0x1f, 0x03, 0xee, 0x3b, 0xd6, 0xa8, 0xc9, 0x24, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xc9, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xce, 0x6c, 0xff, 0xae, 0x4d, 0xfd, 0x29, 0x4a, 0xae, 0xa3, 0x9f, 0xaf, 0x38, 0x22, 0x7c, 0x96, 0xdd, 0xdb, 0xdb, 0x48, 0x86, 0x11, 0x0e, 0x85, 0xa1, 0x21, 0x0f, 0xdb, 0xa3, 0x85, 0x39, 0x4c, 0x47, 0x70, 0x1c, 0xf5, 0xbc, 0xc0, 0x54, 0xe5, 0x73, 0x5e, 0x88, 0x91, 0x98, 0x51, 0x2b, 0x4b, 0xe2, 0xc7, 0x15, 0xaf, 0x77, 0xb4, 0x90, 0x44, 0x5b, 0x78, 0x84, 0x1d, 0xf7, 0x46, 0x7c, 0xd7, 0x6e, 0x25, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x15, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xca, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x04, 0x04, 0x03, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xb2, 0x8b, 0x5f, 0x3f, 0x52, 0xe0, 0xb5, 0x0a, 0xcd, 0xf4, 0xd6, 0x8f, 0x04, 0x86, 0x66, 0x07, 0xc5, 0x65, 0x42, 0x6a, 0xd9, 0xcf, 0x46, 0x53, 0x23, 0x33, 0xe4, 0x7e, 0x76, 0xc4, 0xe5, 0x99, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xd4, 0x53, 0xcc, 0x47, 0x6a, 0x56, 0x62, 0x96, 0x4c, 0xe6, 0xee, 0xcd, 0xdb, 0x78, 0xef, 0xb4, 0x0e, 0x16, 0x16, 0x22, 0x3d, 0x4c, 0x7f, 0xd5, 0x4f, 0x6c, 0xa8, 0x4a, 0xbd, 0xc8, 0x7e, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x0b, 0x50, 0x0a, 0x01, 0xc9, 0x92, 0x6e, 0x36, 0xf8, 0x91, 0x39, 0x67, 0x38, 0x2f, 0xd7, 0x67, 0xa4, 0x83, 0x09, 0xa2, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x02, 0x46, 0x30, 0x43, 0x02, 0x1f, 0x19, 0x21, 0x21, 0x6d, 0x69, 0x30, 0x4c, 0x9f, 0x52, 0x3f, 0xab, 0xd3, 0x9e, 0x12, 0xf9, 0x8d, 0xc0, 0xc2, 0xd9, 0xd4, 0x59, 0x8c, 0x28, 0x49, 0x4c, 0x92, 0xb0, 0x65, 0xd2, 0x5a, 0x57, 0x02, 0x20, 0x12, 0x1a, 0xe3, 0xff, 0x0f, 0xeb, 0x34, 0x9b, 0x7f, 0x35, 0x7b, 0xc6, 0xbc, 0x98, 0x16, 0x3d, 0xa8, 0x2c, 0xa6, 0x3f, 0x6a, 0xe5, 0x1f, 0xcf, 0x79, 0x1f, 0xf0, 0xc4, 0x0a, 0x06, 0x8a, 0xc7, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x8e, 0xfc, 0xab, 0x0b, 0xcc, 0xe7, 0xa6, 0xb2, 0x24, 0x85, 0x59, 0x8a, 0x2e, 0xb9, 0x28, 0x09, 0x22, 0x62, 0xc9, 0x5f, 0x2e, 0xa2, 0x33, 0xbe, 0xab, 0x34, 0x30, 0x44, 0x01, 0x32, 0x69, 0xdd, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x62, 0xeb, 0x8d, 0x4b, 0xaf, 0xe6, 0x85, 0x55, 0xc2, 0x98, 0x9c, 0xc1, 0x10, 0x3e, 0x10, 0x66, 0xc9, 0xf2, 0x76, 0xef, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x01, 0xc3, 0x18, 0x90, 0x21, 0x6a, 0xb8, 0x5a, 0xf7, 0x55, 0xb4, 0xa2, 0xf2, 0xbe, 0x55, 0x90, 0x1d, 0xa8, 0xa8, 0x6f, 0xf3, 0x2b, 0xbb, 0x7b, 0x7c, 0x2d, 0x12, 0x6a, 0xc2, 0x84, 0xd5, 0xf1, 0x02, 0x20, 0x44, 0x08, 0x73, 0x61, 0x5e, 0xdf, 0x76, 0x4d, 0x68, 0x6a, 0x42, 0x20, 0x53, 0x3b, 0x10, 0x18, 0xe2, 0xb0, 0x62, 0xdd, 0x00, 0x35, 0xad, 0xfc, 0x47, 0x83, 0x39, 0x25, 0xc6, 0xd2, 0x86, 0x32, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xe4, 0x0e, 0xe1, 0xa3, 0xa4, 0xf5, 0x76, 0x4d, 0x49, 0xf9, 0xb3, 0x52, 0xa2, 0xe1, 0x81, 0xeb, 0xe4, 0xae, 0x76, 0x7e, 0x00, 0x58, 0xd3, 0x8f, 0xde, 0xba, 0xf8, 0x8e, 0x7d, 0xa4, 0xe9, 0xe1, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x30, 0xfc, 0x80, 0x6e, 0xfe, 0xe1, 0xbc, 0x09, 0x7a, 0xb6, 0xd0, 0xa7, 0xa4, 0x0e, 0xdb, 0x4f, 0xa6, 0xc5, 0xf8, 0x75, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x37, 0x3c, 0x65, 0xfc, 0x21, 0x4f, 0x21, 0x19, 0xd5, 0x5b, 0x1f, 0xa4, 0x00, 0x5d, 0x84, 0x92, 0x71, 0x24, 0x87, 0x64, 0xbb, 0xfa, 0x39, 0xaa, 0x1a, 0xef, 0x82, 0x46, 0xf3, 0x4c, 0xd9, 0xdb, 0x02, 0x20, 0x53, 0x65, 0x63, 0x30, 0x21, 0x53, 0xbe, 0x01, 0xf6, 0xae, 0x6b, 0xf5, 0xe4, 0x48, 0x33, 0xeb, 0x6a, 0x73, 0x93, 0x87, 0x77, 0xd5, 0x55, 0xe9, 0x4e, 0xf7, 0xed, 0x67, 0xb5, 0x5b, 0x39, 0xc9, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xa7, 0x66, 0x01, 0x19, 0xcb, 0x01, 0x23, 0x85, 0x04, 0x85, 0x0c, 0x25, 0x28, 0xb3, 0xb3, 0x71, 0xcd, 0x1f, 0x58, 0x95, 0xda, 0x5e, 0x62, 0x0f, 0xc0, 0xa0, 0x44, 0x83, 0x62, 0x57, 0xbf, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xfb, 0xc2, 0xa6, 0x7e, 0xa3, 0xea, 0x1b, 0xb1, 0xe7, 0x7a, 0x9f, 0x19, 0x84, 0x92, 0x30, 0x1c, 0xde, 0x68, 0x80, 0x81, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x72, 0xfd, 0x8c, 0xe1, 0xb7, 0x34, 0x2e, 0xbe, 0x2b, 0xf4, 0x2f, 0x0b, 0x90, 0x30, 0x42, 0x60, 0xf5, 0x5c, 0xa2, 0x1c, 0x22, 0x63, 0x0a, 0x19, 0xad, 0x0a, 0xc8, 0xed, 0xe0, 0x4d, 0x42, 0xcb, 0x02, 0x20, 0x0f, 0x00, 0xc7, 0xe9, 0x09, 0x3a, 0xe0, 0xc3, 0x8c, 0xd8, 0xd5, 0xca, 0x52, 0xc1, 0x9b, 0xac, 0x13, 0x92, 0x05, 0xc5, 0x35, 0x95, 0x90, 0x65, 0xb7, 0x7a, 0x49, 0xee, 0xdb, 0xcb, 0x58, 0x86, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xf9, 0x12, 0x65, 0x03, 0xbe, 0x10, 0x01, 0x08, 0x01, 0x02, 0xab, 0x12, 0x2a, 0x12, 0x3a, 0x6c, 0xcd, 0xff, 0x5a, 0x94, 0x01, 0x7c, 0x15, 0xa6, 0xf1, 0x40, 0x12, 0xfb, 0xb8, 0xa8, 0xfd, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xcf, 0x93, 0x82, 0xf4, 0xd7, 0xb1, 0x11, 0xdc, 0x9a, 0x60, 0x79, 0xa7, 0xec, 0x40, 0x93, 0x57, 0x9e, 0xb1, 0xec, 0x4c, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x43, 0xed, 0x9d, 0xee, 0xcd, 0x32, 0xf4, 0xba, 0x5e, 0xda, 0x9d, 0xd6, 0xc5, 0xb2, 0x2c, 0xa3, 0xdd, 0xd6, 0x2b, 0x50, 0x88, 0xad, 0x98, 0xcd, 0x12, 0x43, 0x14, 0x1b, 0x40, 0xf2, 0x4a, 0x0a, 0x02, 0x20, 0x7b, 0x7f, 0x01, 0x85, 0x3b, 0x52, 0xf4, 0x3a, 0x5c, 0x0a, 0xdb, 0xb9, 0xa2, 0x98, 0xf2, 0xad, 0xa4, 0xa7, 0xd1, 0xc5, 0x06, 0x26, 0xa5, 0x90, 0xfd, 0xf4, 0xb8, 0xb8, 0x14, 0xfa, 0x8c, 0x28, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xf8, 0x48, 0x1e, 0x6e, 0x63, 0xa7, 0x95, 0xf6, 0x46, 0xf1, 0xd0, 0x6c, 0xac, 0xdd, 0x2d, 0x2c, 0xe7, 0xb1, 0x76, 0xaf, 0xa5, 0x89, 0x33, 0x7e, 0x86, 0x9c, 0x55, 0xe8, 0x64, 0xdf, 0xec, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x3c, 0xc7, 0x3c, 0xe9, 0x8f, 0xa4, 0xd1, 0x4a, 0x97, 0xd5, 0x20, 0x50, 0x8e, 0xa3, 0x53, 0x21, 0x26, 0x13, 0x35, 0xc2, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x47, 0x83, 0xbb, 0x9f, 0xcb, 0x96, 0xde, 0xfb, 0x63, 0x21, 0x09, 0xc9, 0x40, 0x46, 0x7a, 0x4e, 0x13, 0x29, 0x14, 0x12, 0x52, 0xd6, 0x43, 0x37, 0x39, 0x3e, 0x14, 0x23, 0xc0, 0x21, 0xfb, 0xf9, 0x02, 0x20, 0x63, 0x46, 0xbe, 0x30, 0xe0, 0x66, 0x25, 0x1f, 0x1e, 0x47, 0xd8, 0x08, 0x88, 0x9f, 0xab, 0x87, 0xf2, 0xcc, 0x4a, 0x05, 0x79, 0xc9, 0x46, 0xb1, 0xf7, 0xe3, 0x18, 0x0d, 0x4f, 0xf5, 0x20, 0x7f, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x88, 0x75, 0x2a, 0xe7, 0x73, 0xa4, 0x15, 0x40, 0x22, 0x50, 0x7a, 0xed, 0x80, 0x6c, 0x7e, 0xe5, 0x04, 0x45, 0xa9, 0x22, 0x11, 0xb0, 0x2c, 0x10, 0xff, 0x86, 0x07, 0x0d, 0x35, 0x3a, 0xc9, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x45, 0x99, 0xeb, 0xc5, 0x7a, 0xda, 0xa8, 0x2f, 0xce, 0x98, 0xd5, 0xf1, 0xf7, 0xbc, 0x4c, 0x5d, 0x09, 0x41, 0x22, 0x9b, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x0b, 0x7d, 0xaf, 0xde, 0x98, 0xde, 0x40, 0x9e, 0xd4, 0xd1, 0x71, 0x23, 0xa0, 0xd4, 0xc7, 0xd8, 0x3f, 0x54, 0xcc, 0x80, 0xfa, 0x06, 0x28, 0x6f, 0x2b, 0x0a, 0x87, 0x45, 0xb8, 0xe4, 0x59, 0x1c, 0x02, 0x20, 0x26, 0xe8, 0x8d, 0x23, 0x09, 0x97, 0xd2, 0x6d, 0xf6, 0x4f, 0x42, 0x4c, 0xbe, 0x61, 0x5d, 0x4d, 0xce, 0x08, 0x34, 0x6b, 0xff, 0x33, 0xb3, 0xb4, 0x1c, 0x7e, 0x59, 0xb4, 0x62, 0xa8, 0x69, 0x56, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x04, 0xdf, 0xb6, 0x8e, 0x4e, 0x8a, 0x17, 0x16, 0xe1, 0x51, 0xc7, 0x02, 0x8c, 0x8c, 0x0e, 0xa9, 0xe8, 0x0e, 0x98, 0x71, 0xc3, 0xd7, 0xf2, 0xe1, 0xf2, 0x2b, 0x3a, 0x3d, 0x71, 0x9f, 0xb2, 0xa5, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x7c, 0x32, 0xdc, 0x8f, 0x23, 0xa3, 0x6d, 0x63, 0xdb, 0x46, 0x25, 0x64, 0x2b, 0x8c, 0x3f, 0x35, 0x7b, 0x00, 0x1a, 0x33, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x42, 0xac, 0xee, 0xcb, 0x3b, 0xfc, 0xe5, 0xaf, 0x63, 0x9f, 0x22, 0x97, 0x67, 0xad, 0xd6, 0xcb, 0x21, 0x70, 0xd0, 0xbb, 0x6e, 0x34, 0x7f, 0x46, 0x90, 0xf5, 0xc1, 0x78, 0x0f, 0xa8, 0x3f, 0x7a, 0x02, 0x20, 0x4f, 0x21, 0x6d, 0xe3, 0x6e, 0x53, 0xbd, 0xc0, 0x83, 0xc9, 0xa5, 0x89, 0x56, 0x2e, 0xea, 0x18, 0x8d, 0xc5, 0x7b, 0x68, 0x6b, 0x61, 0xdc, 0x7d, 0xa4, 0x1e, 0xf1, 0x3a, 0xc5, 0x7a, 0x4b, 0x54, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x41, 0x9f, 0xf4, 0x0c, 0x0a, 0xf3, 0xe1, 0xf9, 0xbd, 0x99, 0x2e, 0xdf, 0x37, 0x11, 0x8f, 0x70, 0x9a, 0xbc, 0x77, 0x04, 0x58, 0xbb, 0x5f, 0x73, 0xe6, 0x4a, 0x90, 0x68, 0xdd, 0x6a, 0xa2, 0x85, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xd6, 0xb9, 0x71, 0xb4, 0x50, 0x81, 0xc0, 0x58, 0x24, 0x90, 0xc9, 0xf2, 0x5f, 0xda, 0x17, 0x5d, 0x1b, 0x25, 0x9d, 0xaa, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x76, 0x64, 0x57, 0xd5, 0xe2, 0x20, 0x65, 0x0c, 0xc2, 0x09, 0x6f, 0x88, 0xc9, 0x80, 0x08, 0x65, 0x3d, 0x60, 0xbc, 0xff, 0x58, 0x19, 0xaf, 0xba, 0x7d, 0xa7, 0x32, 0x58, 0xb9, 0xf2, 0x9a, 0xf8, 0x02, 0x20, 0x35, 0xa7, 0xa8, 0x11, 0x4c, 0x9c, 0x90, 0x49, 0xdd, 0xec, 0x62, 0xc8, 0xcd, 0x86, 0x67, 0xc1, 0xa9, 0xc0, 0x01, 0xeb, 0x3c, 0x0e, 0x87, 0x6c, 0x40, 0x18, 0xd9, 0xad, 0x1c, 0x87, 0x0c, 0x88, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xa3, 0x71, 0xd4, 0x8b, 0x5a, 0xf5, 0x14, 0x7d, 0x8c, 0xf8, 0xf4, 0x48, 0x9d, 0x62, 0x69, 0x85, 0xd6, 0x42, 0x0f, 0x85, 0x1b, 0xda, 0x7e, 0x70, 0xcc, 0xde, 0xd3, 0xf9, 0x55, 0x66, 0xcc, 0xd9, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x86, 0x85, 0xfc, 0xea, 0xe3, 0x19, 0x33, 0x7a, 0x66, 0x99, 0xef, 0x31, 0xdb, 0x3d, 0x44, 0x91, 0xcf, 0x92, 0xd8, 0xfe, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x6a, 0xa1, 0x24, 0xc9, 0x19, 0xed, 0x0b, 0x52, 0x8d, 0x63, 0x58, 0x6f, 0x6d, 0x99, 0xc5, 0xe3, 0x96, 0x70, 0x09, 0xeb, 0x1d, 0x3e, 0x1f, 0x9a, 0xfa, 0xc8, 0x06, 0x0d, 0x35, 0x12, 0xb1, 0x6c, 0x02, 0x20, 0x2d, 0x70, 0x4a, 0x60, 0x67, 0x00, 0xa6, 0x3a, 0x54, 0xdf, 0xc9, 0xa6, 0xba, 0x4b, 0x4b, 0x00, 0xa0, 0xcb, 0xb4, 0xd9, 0xc3, 0xe0, 0xef, 0x8a, 0x48, 0x9d, 0x1d, 0x41, 0x23, 0x30, 0x2d, 0x97, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xf7, 0x55, 0x80, 0x9a, 0xaf, 0x68, 0x1a, 0x5c, 0x0f, 0x78, 0x39, 0xf6, 0x58, 0x13, 0xaa, 0x6f, 0xc1, 0x71, 0xb2, 0xe5, 0xdc, 0xd8, 0x7f, 0x35, 0xb1, 0x3b, 0x49, 0xb5, 0x63, 0x90, 0x16, 0xae, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xdc, 0x3e, 0x32, 0x43, 0xec, 0x88, 0x17, 0x64, 0xf7, 0xf0, 0x35, 0x96, 0x4d, 0x76, 0xd8, 0x35, 0x7e, 0x79, 0xb4, 0x2b, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x64, 0x43, 0xa6, 0x51, 0x8c, 0x03, 0x09, 0x8a, 0x0b, 0xbd, 0x70, 0xc5, 0x5d, 0xa4, 0x24, 0xdb, 0x5a, 0x88, 0xa1, 0xa8, 0xcd, 0x80, 0xef, 0x62, 0xac, 0x82, 0xab, 0xc9, 0xb6, 0x02, 0x00, 0x8f, 0x02, 0x20, 0x2f, 0xfb, 0xa0, 0x95, 0xaf, 0x19, 0x17, 0x35, 0xca, 0x4c, 0x21, 0xb4, 0xef, 0x47, 0x45, 0x2e, 0x64, 0x44, 0x4a, 0x33, 0xc0, 0x2d, 0x0b, 0x03, 0xeb, 0x5a, 0x46, 0xdc, 0xe6, 0x98, 0x81, 0x2b, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x77, 0xe2, 0x4b, 0x23, 0xc5, 0x38, 0x57, 0x08, 0x50, 0x10, 0x84, 0x45, 0x17, 0x3c, 0xfb, 0xa3, 0xc5, 0xba, 0xa6, 0xee, 0x6a, 0xf1, 0x6f, 0x80, 0x7e, 0x7f, 0x56, 0xb7, 0x72, 0xbb, 0x29, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xb1, 0x4b, 0xdf, 0xa0, 0x16, 0xb8, 0x4f, 0xea, 0xf1, 0xb0, 0x5b, 0xd9, 0x5e, 0x20, 0xc0, 0x06, 0x81, 0x32, 0xb3, 0xc7, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x20, 0x55, 0x18, 0x9e, 0x7d, 0xa9, 0x6f, 0x88, 0x6f, 0xd7, 0xc7, 0x4a, 0x7b, 0x54, 0xb5, 0xc8, 0x6a, 0xc4, 0x3c, 0x63, 0x14, 0xd2, 0xfe, 0x63, 0x20, 0x32, 0xcc, 0xeb, 0x30, 0xa2, 0x8d, 0x49, 0x02, 0x20, 0x15, 0x61, 0xb8, 0xe2, 0x62, 0x05, 0xaa, 0x1f, 0x51, 0x19, 0x94, 0xe1, 0x73, 0xd6, 0x6f, 0xaf, 0x0f, 0x9f, 0x78, 0x63, 0xa4, 0xe0, 0x87, 0x1b, 0x01, 0x27, 0xf8, 0x99, 0x54, 0x64, 0xc6, 0xa1, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x32, 0xe5, 0x4e, 0xa8, 0x50, 0x2d, 0x51, 0xb0, 0x5b, 0xca, 0x7f, 0x98, 0x1c, 0x5a, 0xc0, 0xf3, 0x91, 0x8d, 0xd0, 0x2d, 0xc1, 0x78, 0x20, 0x6f, 0x36, 0x95, 0x7e, 0x6d, 0xaf, 0x2a, 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x00, 0x3a, 0xf3, 0x78, 0xd7, 0x8f, 0xa3, 0x98, 0x53, 0xa9, 0xa1, 0xeb, 0x44, 0xf6, 0xeb, 0x91, 0x91, 0xe1, 0x0e, 0x35, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x09, 0xd2, 0xf7, 0x4b, 0xa7, 0x44, 0x78, 0xcb, 0x04, 0x48, 0xda, 0xe6, 0x4c, 0x25, 0x56, 0xa2, 0x01, 0xdb, 0x59, 0x3c, 0xec, 0xb3, 0xf8, 0xd3, 0xdc, 0x10, 0xe6, 0xde, 0x02, 0xc4, 0x8c, 0x27, 0x02, 0x20, 0x3c, 0xc1, 0xca, 0x65, 0xee, 0x94, 0x6c, 0xc5, 0xf9, 0x41, 0x24, 0xea, 0x69, 0xe2, 0xd6, 0xe8, 0x89, 0x02, 0x3e, 0xb9, 0x42, 0x0d, 0x55, 0x10, 0x75, 0x8e, 0xf9, 0x4d, 0x16, 0xa3, 0xb9, 0xd2, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x2a, 0x39, 0x19, 0x05, 0xe0, 0x06, 0xfc, 0xba, 0x72, 0x3d, 0x56, 0xc6, 0xa3, 0xeb, 0x27, 0xef, 0xa4, 0x39, 0x6e, 0xde, 0x18, 0xf9, 0xc5, 0x0e, 0x0b, 0xe9, 0x0d, 0xc1, 0xe9, 0x28, 0xf1, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x84, 0x26, 0xeb, 0xef, 0x3d, 0x7b, 0x6a, 0x73, 0x87, 0x63, 0x1e, 0x03, 0x9f, 0x5d, 0x47, 0x6d, 0x85, 0xd8, 0xa6, 0x93, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x40, 0xb8, 0x07, 0x10, 0x23, 0x9e, 0x68, 0xe2, 0x17, 0x58, 0x6f, 0xb0, 0x76, 0xc0, 0x8f, 0xeb, 0x4a, 0x56, 0x1e, 0xc2, 0xfa, 0xc4, 0x4c, 0x64, 0xea, 0x95, 0xfa, 0xd5, 0xb2, 0x08, 0x32, 0x48, 0x02, 0x20, 0x26, 0x6c, 0x36, 0x4a, 0x85, 0xec, 0x12, 0x70, 0x63, 0xf7, 0x5c, 0xcf, 0x5a, 0x83, 0x15, 0xbe, 0xaf, 0x27, 0xb6, 0x8f, 0xe2, 0x2c, 0x25, 0x3e, 0xb3, 0x54, 0x57, 0x77, 0x54, 0xbc, 0x23, 0x0a, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x8c, 0x36, 0x26, 0xfb, 0x53, 0x89, 0x21, 0xb3, 0xf5, 0x97, 0x86, 0xde, 0x9e, 0x6c, 0xa2, 0x48, 0x7b, 0x3a, 0x1f, 0x5c, 0x80, 0xa3, 0xd9, 0xdd, 0x82, 0xc2, 0x7a, 0x6b, 0x1a, 0x6e, 0xac, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xe5, 0xb0, 0xf7, 0x88, 0xe3, 0x29, 0x23, 0x52, 0xbf, 0x38, 0x5c, 0xdf, 0xe9, 0x23, 0x62, 0x27, 0xd9, 0x06, 0xfe, 0xed, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x20, 0xca, 0x43, 0xcc, 0xab, 0x85, 0xb1, 0xb8, 0x47, 0xa2, 0x5d, 0x4f, 0x51, 0xfd, 0x39, 0x3b, 0xf4, 0xaa, 0x69, 0x1b, 0x32, 0xe0, 0xfc, 0x80, 0xc9, 0x1c, 0x3f, 0x89, 0x3c, 0xb5, 0x2b, 0x21, 0x02, 0x20, 0x45, 0xde, 0x91, 0x77, 0xf9, 0xb6, 0x86, 0xdc, 0x45, 0x84, 0x11, 0xe5, 0xd1, 0xa8, 0x09, 0x5e, 0x55, 0xc7, 0x25, 0x1f, 0x55, 0x93, 0x0f, 0x26, 0x1c, 0x92, 0xc6, 0x83, 0x74, 0xf5, 0xe9, 0xd4, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x4d, 0x96, 0xfa, 0x8c, 0x63, 0x2d, 0xa4, 0x73, 0xf2, 0xab, 0xcd, 0x00, 0x11, 0x84, 0xd1, 0x81, 0x27, 0x09, 0xed, 0x52, 0xe9, 0xc2, 0x58, 0x53, 0x08, 0xb2, 0x87, 0x43, 0xab, 0x75, 0x08, 0xe1, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x2e, 0x6c, 0xe8, 0xb4, 0x8b, 0xaf, 0xa3, 0x84, 0x43, 0xac, 0x0a, 0x9a, 0x04, 0x9c, 0x91, 0x5a, 0x84, 0xd0, 0x7a, 0x1d, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x70, 0x42, 0x9e, 0x86, 0xae, 0xa4, 0xdb, 0x84, 0xdb, 0x3c, 0x3e, 0xca, 0x40, 0x85, 0xef, 0xd7, 0x77, 0xc3, 0x69, 0x60, 0xbb, 0xd2, 0xf1, 0xbe, 0x67, 0x9d, 0xb4, 0xf3, 0x4a, 0x14, 0x8e, 0xd3, 0x02, 0x20, 0x68, 0xa0, 0xa3, 0xf9, 0x02, 0x09, 0x26, 0x61, 0xc0, 0xa5, 0xb4, 0x2e, 0x72, 0x18, 0xb7, 0x71, 0x9e, 0xc3, 0x62, 0xb7, 0xdd, 0x48, 0xad, 0x95, 0xb1, 0xc6, 0x1c, 0x10, 0x72, 0xda, 0x85, 0x80, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x20, 0x3d, 0x91, 0xdd, 0x64, 0x72, 0x10, 0xa0, 0x31, 0x04, 0x6c, 0xfc, 0xcd, 0x09, 0x9e, 0xdb, 0xa9, 0x4b, 0x5c, 0xb0, 0x20, 0x3a, 0xb1, 0xe7, 0xc2, 0x08, 0x15, 0x8c, 0x1c, 0x04, 0xd7, 0xee, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x2b, 0xb1, 0x13, 0x0a, 0xfb, 0xf9, 0xc9, 0x17, 0x5d, 0xb6, 0xe8, 0x25, 0xef, 0x21, 0xff, 0x6a, 0xd9, 0x67, 0x90, 0x3a, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x2f, 0x12, 0x8c, 0xe7, 0xb6, 0xee, 0x67, 0xba, 0xd8, 0x5e, 0x4b, 0x1f, 0xf7, 0xbd, 0xc6, 0xdb, 0xd8, 0x52, 0xdd, 0x04, 0x68, 0x07, 0x3a, 0x07, 0x80, 0xd3, 0x5e, 0x64, 0xe8, 0x64, 0xca, 0x92, 0x02, 0x20, 0x3a, 0x50, 0xa4, 0xd0, 0xaa, 0xbe, 0x69, 0x61, 0x69, 0x61, 0x50, 0xe6, 0xdc, 0x2d, 0xa7, 0x05, 0x3c, 0x10, 0xa7, 0x7b, 0x42, 0xb3, 0xdc, 0xe9, 0x3d, 0x1e, 0x16, 0x8d, 0xaa, 0x9a, 0x56, 0x8d, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x67, 0x6a, 0x90, 0xf9, 0x74, 0x80, 0xef, 0x4e, 0x44, 0x73, 0x35, 0xf1, 0xb9, 0x37, 0x6c, 0x94, 0x43, 0x81, 0xfb, 0x06, 0xd6, 0x9b, 0x77, 0x8a, 0x47, 0x24, 0x8e, 0x57, 0x60, 0xde, 0xdf, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xff, 0x27, 0x06, 0x9b, 0xfa, 0x43, 0x6a, 0x03, 0xf2, 0x77, 0xa5, 0x3d, 0xa9, 0xeb, 0xe7, 0x38, 0xcb, 0x40, 0x58, 0xd5, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x30, 0xcf, 0xaa, 0x52, 0x07, 0xe6, 0xd0, 0xa6, 0x90, 0xed, 0x5a, 0x21, 0x01, 0xa0, 0x67, 0xc7, 0xe4, 0xd1, 0xb3, 0x1f, 0x69, 0x48, 0x86, 0xb4, 0x27, 0x06, 0x5c, 0x5c, 0x97, 0x1d, 0x95, 0xa4, 0x02, 0x20, 0x64, 0x6c, 0xf6, 0x39, 0x56, 0xdc, 0xc3, 0x99, 0xc2, 0x43, 0xff, 0x6a, 0x20, 0x7a, 0xdf, 0xd3, 0x4d, 0x4f, 0x2e, 0x40, 0x9c, 0xd2, 0xec, 0x4a, 0x48, 0xc5, 0x31, 0xe2, 0x14, 0x37, 0x0c, 0x99, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x29, 0x5b, 0xad, 0xc0, 0xbd, 0xd9, 0xa2, 0xbc, 0x09, 0x55, 0xd1, 0x2f, 0x33, 0x74, 0x91, 0xea, 0xe4, 0xc8, 0x7b, 0xa4, 0x66, 0x00, 0x78, 0xc0, 0x15, 0x63, 0x10, 0x28, 0x4d, 0x47, 0xc6, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xc3, 0x4c, 0x2b, 0x12, 0xf2, 0xc5, 0xc3, 0xe3, 0xa0, 0x61, 0xc5, 0xbe, 0x98, 0x85, 0xe9, 0x7b, 0xe3, 0xd1, 0x82, 0xff, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x1d, 0xe1, 0xa3, 0x57, 0x9f, 0x63, 0xea, 0xca, 0xe9, 0x3d, 0x91, 0x9f, 0x6e, 0x7c, 0x6f, 0x38, 0x8e, 0x33, 0xfe, 0x52, 0x28, 0xf7, 0x46, 0x8a, 0x94, 0x07, 0x0e, 0xae, 0x39, 0x08, 0xf1, 0x50, 0x02, 0x20, 0x63, 0x0a, 0x00, 0x11, 0x26, 0xba, 0xa4, 0x96, 0x36, 0x27, 0x02, 0xeb, 0x67, 0x5c, 0x1a, 0xa2, 0x24, 0x4c, 0x5d, 0x6a, 0xf2, 0xf3, 0xaa, 0xda, 0xca, 0x41, 0xeb, 0x09, 0xef, 0x55, 0xb8, 0x40, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x66, 0x86, 0x88, 0xa5, 0xf4, 0x54, 0x5d, 0x86, 0xd0, 0x0b, 0xde, 0xbb, 0x0a, 0x00, 0x7c, 0xaf, 0xc5, 0x30, 0x60, 0x3c, 0x1f, 0xbb, 0x6d, 0x6a, 0x9f, 0x06, 0x9a, 0x1d, 0x5f, 0x10, 0x9f, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x73, 0x10, 0x10, 0x24, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xa0, 0x60, 0xce, 0x26, 0x38, 0xc5, 0x4c, 0xb6, 0x55, 0x70, 0x77, 0x9a, 0x62, 0xbd, 0x3d, 0x80, 0xa5, 0x49, 0x96, 0x78, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x50, 0xd6, 0xd5, 0xb4, 0x91, 0x02, 0xfb, 0x93, 0xcb, 0xb2, 0x4f, 0xb5, 0x3c, 0xf8, 0xe1, 0x9e, 0x83, 0x1a, 0x24, 0xf7, 0x1b, 0x08, 0x77, 0xc3, 0x05, 0x0b, 0xa2, 0x25, 0x00, 0x20, 0xe8, 0x95, 0x02, 0x20, 0x1d, 0x6f, 0x37, 0xb6, 0x1d, 0x60, 0xd1, 0xa0, 0xaf, 0x32, 0xb5, 0x19, 0x18, 0x87, 0xc1, 0xc5, 0x63, 0x20, 0xcf, 0xc0, 0xd5, 0xbd, 0x9c, 0x06, 0x46, 0x34, 0xa4, 0xfe, 0xc8, 0x10, 0x78, 0x2e, 0x01, 0x21, 0x03, 0x00, 0xd9, 0x99, 0x68, 0x4b, 0xd1, 0x23, 0xd7, 0x20, 0x74, 0xbf, 0x26, 0xbf, 0xac, 0xa1, 0x17, 0x75, 0xeb, 0x37, 0x10, 0x29, 0xbf, 0x71, 0x4a, 0x60, 0xbd, 0xd4, 0xe9, 0x76, 0xb1, 0xcc, 0x8f, 0xc9, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x5e, 0x30, 0xa8, 0x50, 0x2b, 0xde, 0xf4, 0xfa, 0xe4, 0x37, 0x33, 0x5f, 0xd1, 0xe4, 0xcd, 0x08, 0x61, 0x68, 0x9b, 0xa6, 0x89, 0xd7, 0x93, 0x97, 0xec, 0x4e, 0x81, 0x0a, 0xb2, 0x8d, 0xb2, 0x70, 0x4c, 0x30, 0x74, 0x5d, 0xe8, 0xc0, 0x77, 0x4b, 0x8f, 0x96, 0x08, 0x74, 0x61, 0xdb, 0xd6, 0xef, 0xa1, 0x9c, 0x13, 0x86, 0xbf, 0x15, 0xd1, 0xe7, 0xe3, 0x05, 0xeb, 0xab, 0xd6, 0xc2, 0x9c, 0xb1, 0x77, 0x25, 0x2d, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xcb, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xe2, 0xf6, 0x1c, 0x3f, 0x71, 0xd1, 0xde, 0xfd, 0x3f, 0xa9, 0x99, 0xdf, 0xa3, 0x69, 0x53, 0x75, 0x5c, 0x69, 0x06, 0x89, 0x79, 0x99, 0x62, 0xb4, 0x8b, 0xeb, 0xd8, 0x36, 0x97, 0x4e, 0x8c, 0xf9, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0xe2, 0x74, 0x85, 0x6b, 0x9c, 0x74, 0x52, 0xea, 0x64, 0x4c, 0x99, 0x1d, 0x4f, 0x3d, 0xe0, 0x49, 0x81, 0x78, 0x31, 0x53, 0x56, 0xc2, 0x49, 0x25, 0x74, 0x11, 0x7b, 0x3d, 0xf2, 0xee, 0xcf, 0x1c, 0xb5, 0x3f, 0xf5, 0x3c, 0x08, 0xd6, 0xd3, 0xec, 0x10, 0xc0, 0xa9, 0x48, 0xb9, 0xdd, 0x2b, 0x4a, 0xae, 0x96, 0x74, 0x3f, 0xc5, 0xd6, 0xbf, 0x2b, 0x12, 0x54, 0xe4, 0x40, 0x7d, 0xaa, 0xa3, 0x17, 0x5c, 0x0f, 0x2e, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x01, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xcc, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x8d, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x14, 0x09, 0x74, 0x54, 0x05, 0xc4, 0xe8, 0x31, 0x0a, 0x87, 0x5b, 0xcd, 0x60, 0x2d, 0xb6, 0xb9, 0xb3, 0xdc, 0x0c, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0x22, 0x88, 0xe4, 0x6f, 0xff, 0x34, 0x29, 0x1c, 0x30, 0x1c, 0x01, 0xe0, 0x40, 0xe7, 0xbd, 0x46, 0x86, 0x21, 0xd7, 0x0a, 0x00, 0x78, 0xa1, 0x1e, 0x42, 0x2e, 0x61, 0x6b, 0x70, 0xd5, 0x1f, 0x4c, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x08, 0x7b, 0x23, 0x4e, 0x0a, 0x26, 0xaa, 0x32, 0x65, 0xfa, 0xaa, 0x7f, 0x7e, 0x50, 0x7f, 0xbb, 0x01, 0xdc, 0x61, 0x38, 0x1d, 0xed, 0x25, 0x47, 0xfd, 0xbe, 0xfe, 0xc2, 0x95, 0x18, 0x6c, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0xe6, 0x2e, 0x1a, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xb0, 0x35, 0x0e, 0xf1, 0xd0, 0x6b, 0x91, 0xd6, 0x81, 0xe3, 0x36, 0x55, 0x61, 0x1f, 0x4f, 0xce, 0x8b, 0x1f, 0x95, 0xe7, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x90, 0xd4, 0x29, 0x04, 0x3a, 0x6a, 0x97, 0xe1, 0xbb, 0x67, 0x75, 0xf7, 0x02, 0xb6, 0x77, 0xe2, 0x13, 0x88, 0xa6, 0xa5, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x58, 0xd8, 0xb0, 0x8b, 0x6c, 0x1d, 0xcf, 0x2d, 0x15, 0x93, 0xf8, 0xe2, 0xdf, 0x01, 0x16, 0x54, 0xb0, 0x40, 0x09, 0x29, 0x07, 0x44, 0xdf, 0x42, 0xa8, 0x1e, 0x26, 0x3c, 0x14, 0x62, 0xb5, 0xdc, 0x02, 0x20, 0x3f, 0x34, 0x57, 0x08, 0xfb, 0x68, 0xd7, 0xc2, 0xc6, 0x0d, 0xb7, 0x65, 0xca, 0xbb, 0x5e, 0xf9, 0xad, 0x76, 0xb1, 0x5e, 0x89, 0x21, 0x2c, 0x23, 0xb9, 0xaf, 0xa2, 0xb2, 0xf1, 0x6e, 0xa5, 0x8f, 0x01, 0x21, 0x02, 0x25, 0x36, 0x3b, 0x30, 0x25, 0x7a, 0x7d, 0x3a, 0x27, 0xc4, 0xb0, 0x3d, 0x31, 0x2b, 0xc0, 0x56, 0x8a, 0x26, 0x35, 0x03, 0x10, 0x7e, 0xbb, 0xd5, 0x4b, 0x8d, 0x24, 0xc0, 0x23, 0xc3, 0xdc, 0x20, 0x00, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x75, 0xd4, 0x53, 0xe2, 0xfc, 0xdc, 0x9d, 0xd1, 0xdd, 0x0f, 0x10, 0x81, 0xb2, 0xe2, 0xfb, 0xd0, 0x40, 0x0a, 0xae, 0x4b, 0x12, 0x41, 0x25, 0x24, 0xa4, 0xab, 0x6c, 0xed, 0x86, 0x9e, 0x62, 0x4a, 0x3b, 0x21, 0x11, 0x01, 0xd7, 0xa9, 0x9e, 0x85, 0xed, 0xd6, 0x1c, 0xdd, 0x0a, 0x1e, 0xe1, 0x67, 0xf2, 0xc5, 0x01, 0x5e, 0x42, 0x96, 0xc6, 0x92, 0xf5, 0x04, 0x08, 0xc4, 0x6b, 0x31, 0x56, 0xa3, 0x56, 0x11, 0x2e, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xcd, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0xa7, 0xfa, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xeb, 0x82, 0x05, 0x93, 0x11, 0xa8, 0x07, 0xfc, 0x28, 0x9d, 0x46, 0xa7, 0x15, 0xea, 0x48, 0x01, 0x60, 0x8e, 0x56, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0x61, 0x52, 0x99, 0x7c, 0xdf, 0x8a, 0x1f, 0x59, 0x8b, 0x3b, 0x28, 0x1f, 0x4c, 0x23, 0x71, 0xff, 0x57, 0xf1, 0x6a, 0xde, 0xe3, 0x87, 0xd2, 0xc6, 0xf9, 0xa1, 0x22, 0x32, 0x94, 0xab, 0xbb, 0x86, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x0c, 0x82, 0x76, 0xe5, 0x84, 0x15, 0xe6, 0x3f, 0x76, 0xb5, 0xb9, 0xae, 0xe5, 0xdc, 0x13, 0xe3, 0x6d, 0x2d, 0x86, 0xc5, 0xe6, 0xe9, 0x6b, 0x66, 0x8d, 0x9b, 0x02, 0x93, 0x68, 0xad, 0xa7, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x59, 0x4d, 0x24, 0x18, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x65, 0x74, 0x19, 0xc1, 0xc1, 0x15, 0x14, 0x06, 0x63, 0xbc, 0x9a, 0x3e, 0x54, 0x73, 0x70, 0x4a, 0xe2, 0x2a, 0xad, 0xeb, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xcd, 0x0b, 0xa0, 0x17, 0x21, 0xf6, 0x48, 0x1d, 0x58, 0xac, 0xff, 0xb9, 0xc2, 0xc0, 0x55, 0x8a, 0xda, 0xcd, 0x9a, 0x81, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x20, 0x7c, 0xb4, 0x2a, 0x79, 0x2d, 0xb1, 0x08, 0xf6, 0x1a, 0xb0, 0x19, 0x69, 0x5c, 0x2b, 0x5d, 0x19, 0xd6, 0x27, 0x00, 0x46, 0xbd, 0x85, 0x49, 0x74, 0x61, 0xc7, 0x22, 0x75, 0x3c, 0xa5, 0xf0, 0x02, 0x20, 0x6f, 0x83, 0xb5, 0x71, 0x07, 0x7c, 0xb6, 0xa6, 0x83, 0x01, 0x5e, 0xcd, 0x34, 0x8e, 0xeb, 0x09, 0x53, 0x6a, 0x6e, 0x61, 0x67, 0x5a, 0x40, 0x62, 0xee, 0x27, 0x75, 0xbc, 0x13, 0xff, 0x4f, 0x6a, 0x01, 0x21, 0x03, 0xfa, 0x84, 0xa8, 0xe7, 0x35, 0xee, 0x9e, 0xd2, 0xc5, 0x61, 0x21, 0x40, 0x6c, 0x3a, 0xb2, 0xa4, 0xb8, 0xc5, 0x98, 0xa1, 0xd6, 0x4e, 0xbf, 0x7a, 0xe8, 0xed, 0xaa, 0xaa, 0xb8, 0x29, 0x26, 0x38, 0xcc, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x2c, 0x9e, 0x15, 0x68, 0x2c, 0x8e, 0xe7, 0x8b, 0xb3, 0x7d, 0xfd, 0xa5, 0x91, 0xea, 0xfb, 0xa3, 0x13, 0x35, 0x4b, 0x44, 0xdc, 0x36, 0xa9, 0x66, 0x32, 0x62, 0x3f, 0x43, 0x42, 0x9a, 0x24, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0xe6, 0x2e, 0x1a, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xc9, 0x75, 0xd6, 0x0b, 0xc9, 0xd9, 0xed, 0xf5, 0x19, 0x89, 0xe7, 0x17, 0xeb, 0xe0, 0x9c, 0xf1, 0x40, 0xa3, 0xb1, 0x9d, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x4c, 0x8a, 0xf9, 0x62, 0x10, 0xbc, 0x0e, 0x19, 0x3e, 0x9b, 0x7d, 0x40, 0x35, 0x32, 0x23, 0x48, 0x50, 0x15, 0xe2, 0xb7, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x23, 0xa5, 0xdf, 0xb9, 0xaf, 0xcb, 0x73, 0x8e, 0xe1, 0xac, 0xa7, 0xc2, 0xb6, 0x89, 0x3c, 0xed, 0x1c, 0xdf, 0x58, 0xbd, 0x86, 0x55, 0xb9, 0x6c, 0x15, 0x7f, 0xde, 0xa4, 0xa4, 0x98, 0xbe, 0x27, 0x02, 0x20, 0x5a, 0x3b, 0xd3, 0x61, 0xd9, 0xd2, 0xdc, 0x47, 0x5c, 0xca, 0xc0, 0x69, 0xf0, 0x77, 0x5e, 0xa9, 0xdc, 0x6c, 0xdb, 0x63, 0x08, 0x76, 0xa6, 0xcb, 0x79, 0xc6, 0x7b, 0x28, 0xd5, 0x50, 0xfb, 0x53, 0x01, 0x21, 0x03, 0xfa, 0xd0, 0xc0, 0xcd, 0xc5, 0xe4, 0x73, 0x8a, 0xc2, 0xdc, 0x0d, 0x5f, 0x30, 0x0a, 0x9d, 0x8f, 0xd0, 0x95, 0xe1, 0xf2, 0xbb, 0x13, 0x29, 0x1e, 0x6d, 0xaa, 0x7c, 0xb6, 0x69, 0x1b, 0x27, 0x80, 0xcc, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x13, 0xf3, 0x6a, 0xcf, 0x4e, 0xb1, 0x16, 0xcd, 0x89, 0xb8, 0x70, 0x93, 0x17, 0xd8, 0x7c, 0x5a, 0x2d, 0xaf, 0x00, 0xe5, 0xd6, 0xcf, 0x33, 0xc9, 0xeb, 0x0d, 0x9e, 0x3d, 0x29, 0x07, 0x29, 0xca, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0xe6, 0x2e, 0x1a, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0x79, 0xc3, 0xe8, 0x43, 0x33, 0x84, 0x76, 0x39, 0xf9, 0x03, 0x25, 0xfd, 0x9a, 0x86, 0xde, 0x8d, 0xd4, 0x02, 0x56, 0xa0, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xd1, 0x49, 0xc0, 0x3a, 0xf8, 0x6d, 0x5a, 0xa2, 0x12, 0x13, 0xdb, 0x62, 0x07, 0x63, 0xee, 0x75, 0x34, 0xc5, 0x4f, 0xf6, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x1f, 0xd8, 0x4f, 0xaf, 0x54, 0x03, 0x0f, 0x6e, 0x5d, 0xf5, 0xb8, 0xb7, 0x1f, 0x49, 0xb4, 0xe6, 0x9d, 0xcc, 0x68, 0x56, 0xcd, 0x3c, 0xcd, 0x65, 0x7f, 0x11, 0x48, 0x1b, 0xf1, 0xa4, 0xfc, 0x8f, 0x02, 0x20, 0x42, 0xd5, 0xb4, 0x75, 0xf4, 0x8d, 0x2e, 0x25, 0xa6, 0xee, 0x20, 0x6d, 0x7c, 0x84, 0x41, 0x49, 0x37, 0x12, 0xd9, 0xd2, 0x62, 0xd4, 0x72, 0xc1, 0xdf, 0x2c, 0x5b, 0x7c, 0x7f, 0xe9, 0xff, 0xb1, 0x01, 0x21, 0x02, 0xd0, 0xa8, 0x10, 0x09, 0x3c, 0x36, 0xca, 0x0e, 0x81, 0x50, 0x79, 0xae, 0x76, 0x99, 0x2d, 0x1b, 0xf5, 0xcf, 0x60, 0x57, 0x3b, 0xec, 0x8b, 0x73, 0x57, 0x2b, 0x20, 0xc8, 0x9e, 0xbc, 0x9b, 0x45, 0xc1, 0x00, 0x00, 0x00,
+},
+{0x00, 0x00, 0x00, 0x30, 0x55, 0x17, 0x1b, 0xe9, 0xb7, 0xf6, 0x2e, 0x71, 0x9a, 0x3d, 0x44, 0xda, 0xa5, 0x6c, 0xf3, 0xa8, 0x90, 0x3f, 0x66, 0x32, 0x7b, 0x68, 0x54, 0xd5, 0x7c, 0x6d, 0x66, 0x78, 0xd7, 0xb4, 0xe7, 0x28, 0xc7, 0xc6, 0x75, 0x66, 0x83, 0x3f, 0x9b, 0x61, 0x09, 0xcb, 0x1a, 0x5e, 0xb5, 0x0b, 0x81, 0x1d, 0x1a, 0xe9, 0x7a, 0x1f, 0x20, 0xc3, 0x91, 0x2e, 0xb7, 0xd1, 0xc5, 0xff, 0xf7, 0x24, 0x50, 0x09, 0x2a, 0xc5, 0x38, 0x66, 0xff, 0xff, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x02, 0xce, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0xe8, 0xf9, 0x02, 0x95, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x14, 0xeb, 0x82, 0x05, 0x93, 0x11, 0xa8, 0x07, 0xfc, 0x28, 0x9d, 0x46, 0xa7, 0x15, 0xea, 0x48, 0x01, 0x60, 0x8e, 0x56, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed, 0xcb, 0x93, 0xaa, 0x8d, 0xfe, 0x2d, 0x28, 0x21, 0x9d, 0x42, 0xca, 0xec, 0x8a, 0x36, 0x7d, 0xf5, 0xb1, 0xe1, 0xe4, 0xa1, 0xe2, 0x00, 0x2b, 0xfd, 0xf4, 0x39, 0xd8, 0x3c, 0xa5, 0x3d, 0xc0, 0x8c, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0xbb, 0xbd, 0x77, 0xf0, 0xd8, 0xc5, 0xcb, 0xc2, 0xcc, 0xc3, 0x9f, 0x05, 0x01, 0x82, 0x8a, 0xd4, 0xac, 0x3a, 0x6a, 0x93, 0x33, 0x93, 0x87, 0x6c, 0xae, 0x5a, 0x7e, 0x49, 0xbd, 0x53, 0x41, 0x23, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x94, 0xe2, 0x99, 0xc8, 0x37, 0xe0, 0xe0, 0x06, 0x44, 0xb9, 0x12, 0x3d, 0x80, 0xc0, 0x52, 0x15, 0x94, 0x43, 0x90, 0x7f, 0x66, 0x3e, 0x74, 0x6b, 0xe7, 0xfe, 0x1e, 0x6c, 0x32, 0xc3, 0xee, 0x9b, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0x02, 0x18, 0xe0, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x22, 0x51, 0x20, 0xd7, 0xbf, 0x24, 0xe1, 0x3d, 0xaf, 0x4d, 0x6c, 0xe0, 0xac, 0x7a, 0x34, 0xec, 0xef, 0xb4, 0x12, 0x2f, 0x07, 0x0a, 0x15, 0x61, 0xe8, 0x65, 0x9d, 0x40, 0x71, 0xc5, 0x2e, 0xdb, 0x7c, 0x1c, 0xb3, 0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, 0x22, 0x51, 0x20, 0x7e, 0xf1, 0x57, 0x80, 0x91, 0x6a, 0xe0, 0xf2, 0x9a, 0x0b, 0xd3, 0x4e, 0x48, 0xe1, 0xa0, 0xe8, 0x17, 0xe7, 0x73, 0x1b, 0x82, 0xf3, 0x00, 0x9c, 0xfa, 0x89, 0xc8, 0x76, 0x02, 0xcf, 0x1b, 0x2b, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x14, 0x68, 0x0d, 0x9a, 0x96, 0x38, 0x68, 0xb0, 0x3d, 0x25, 0xf8, 0x4b, 0xd8, 0x1a, 0xf8, 0x7e, 0x12, 0x7f, 0x9d, 0x79, 0x90, 0x16, 0x6d, 0xad, 0x5e, 0x1d, 0xd7, 0x1b, 0xe8, 0x79, 0x7e, 0x34, 0x02, 0x20, 0x5f, 0x79, 0x71, 0x3b, 0x4f, 0xaa, 0xff, 0x71, 0x84, 0xfb, 0x25, 0xd0, 0x97, 0x6a, 0x37, 0x97, 0x0f, 0x8d, 0x6b, 0x23, 0xf9, 0x5d, 0x40, 0x41, 0x18, 0x0a, 0x35, 0xaa, 0x29, 0x1f, 0xc8, 0xdc, 0x01, 0x21, 0x02, 0xa9, 0xdf, 0xae, 0xee, 0xba, 0xd1, 0xf7, 0xeb, 0xca, 0x37, 0x1a, 0x6f, 0x02, 0xe6, 0x3a, 0x8b, 0x0d, 0xe2, 0x87, 0xc1, 0xb0, 0x60, 0x8e, 0xdc, 0x25, 0x9c, 0x60, 0x58, 0x3a, 0x03, 0x49, 0x6e, 0x02, 0x47, 0x30, 0x44, 0x02, 0x20, 0x1f, 0x09, 0xec, 0xdb, 0x89, 0xf3, 0x11, 0xc3, 0xad, 0x8b, 0x6d, 0x89, 0xa0, 0x40, 0xa5, 0x79, 0x6f, 0x83, 0xc9, 0xdb, 0x25, 0x97, 0x96, 0x29, 0x69, 0x39, 0x2a, 0x3d, 0x9a, 0x5b, 0xe4, 0x6d, 0x02, 0x20, 0x52, 0x24, 0x34, 0x18, 0xa8, 0x98, 0x31, 0xca, 0x0e, 0x5d, 0xdd, 0x7a, 0xe5, 0x75, 0xd7, 0x87, 0x17, 0x81, 0x26, 0xd8, 0x49, 0x5f, 0x89, 0x04, 0x14, 0xab, 0x8b, 0x4d, 0x2a, 0x1b, 0x19, 0xd8, 0x01, 0x21, 0x03, 0x53, 0x68, 0xc7, 0x52, 0xd3, 0xee, 0x31, 0xd9, 0x57, 0x01, 0x80, 0xa1, 0xba, 0x28, 0x56, 0x59, 0xaf, 0x10, 0x6f, 0x94, 0x30, 0x81, 0x1e, 0xc5, 0x8e, 0x3b, 0x86, 0xcf, 0x26, 0xc2, 0x08, 0xf1, 0x00, 0x00, 0x00, 0x00,
+},
+};
+#endif // BITCOIN_TEST_KERNEL_BLOCK_DATA_H
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index 74f162b5000..d793841120d 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -8,6 +8,8 @@
 #define BOOST_TEST_MODULE Bitcoin Kernel Test Suite
 #include <boost/test/included/unit_test.hpp>
 
+#include <test/kernel/block_data.h>
+
 #include <charconv>
 #include <cstdint>
 #include <cstdlib>
@@ -63,6 +65,11 @@ constexpr auto VERIFY_ALL_PRE_SEGWIT{ScriptVerificationFlags::P2SH | ScriptVerif
                                      ScriptVerificationFlags::CHECKSEQUENCEVERIFY};
 constexpr auto VERIFY_ALL_PRE_TAPROOT{VERIFY_ALL_PRE_SEGWIT | ScriptVerificationFlags::WITNESS};
 
+std::span<const std::byte> as_bytes(std::vector<unsigned char> data)
+{
+    return std::span{reinterpret_cast<const std::byte*>(data.data()), data.size()};
+}
+
 void check_equal(std::span<const std::byte> _actual, std::span<const std::byte> _expected, bool equal = true)
 {
     std::span<const uint8_t> actual{reinterpret_cast<const unsigned char*>(_actual.data()), _actual.size()};
@@ -473,6 +480,15 @@ BOOST_AUTO_TEST_CASE(btck_context_tests)
     }
 }
 
+BOOST_AUTO_TEST_CASE(btck_block)
+{
+    Block block{as_bytes(REGTEST_BLOCK_DATA[0])};
+    Block block_1{as_bytes(REGTEST_BLOCK_DATA[1])};
+    CheckHandle(block, block_1);
+    Block block_tx{as_bytes(REGTEST_BLOCK_DATA[205])};
+    CheckRange(block_tx.Transactions(), block_tx.CountTransactions());
+}
+
 Context create_context(std::shared_ptr<TestKernelNotifications> notifications, ChainType chain_type)
 {
     ContextOptions options{};
@@ -515,3 +531,94 @@ BOOST_AUTO_TEST_CASE(btck_chainman_tests)
     chainman_opts.SetWorkerThreads(4);
     ChainMan chainman{context, chainman_opts};
 }
+
+std::unique_ptr<ChainMan> create_chainman(TestDirectory& test_directory,
+                                          Context& context)
+{
+    ChainstateManagerOptions chainman_opts{context, test_directory.m_directory.string(), (test_directory.m_directory / "blocks").string()};
+    auto chainman{std::make_unique<ChainMan>(context, chainman_opts)};
+    return chainman;
+}
+
+BOOST_AUTO_TEST_CASE(btck_chainman_mainnet_tests)
+{
+    btck_LoggingOptions logging_options = {
+        .log_timestamps = true,
+        .log_time_micros = true,
+        .log_threadnames = false,
+        .log_sourcelocations = false,
+        .always_print_category_levels = true,
+    };
+    Logger logger{std::make_unique<TestLog>(TestLog{}), logging_options};
+
+    auto mainnet_test_directory{TestDirectory{"mainnet_test_bitcoin_kernel"}};
+
+    auto notifications{std::make_shared<TestKernelNotifications>()};
+    auto context{create_context(notifications, ChainType::MAINNET)};
+    auto chainman{create_chainman(mainnet_test_directory, context)};
+
+    {
+        // Process an invalid block
+        auto raw_block = hex_string_to_byte_vec("012300");
+        BOOST_CHECK_THROW(Block{raw_block}, std::runtime_error);
+    }
+    {
+        // Process an empty block
+        auto raw_block = hex_string_to_byte_vec("");
+        BOOST_CHECK_THROW(Block{raw_block}, std::runtime_error);
+    }
+
+    // mainnet block 1
+    auto raw_block = hex_string_to_byte_vec("010000006fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000982051fd1e4ba744bbbe680e1fee14677ba1a3c3540bf7b1cdb606e857233e0e61bc6649ffff001d01e362990101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0704ffff001d0104ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac00000000");
+    Block block{raw_block};
+    TransactionView tx{block.GetTransaction(block.CountTransactions() - 1)};
+    BOOST_CHECK_EQUAL(tx.CountInputs(), 1);
+    Transaction tx2 = tx;
+    BOOST_CHECK_EQUAL(tx2.CountInputs(), 1);
+    for (auto transaction : block.Transactions()) {
+        BOOST_CHECK_EQUAL(transaction.CountInputs(), 1);
+    }
+    auto output_counts = *(block.Transactions() | std::views::transform([](const auto& tx) {
+                               return tx.CountOutputs();
+                           })).begin();
+    BOOST_CHECK_EQUAL(output_counts, 1);
+    bool new_block = false;
+    BOOST_CHECK(chainman->ProcessBlock(block, &new_block));
+    BOOST_CHECK(new_block);
+
+    // If we try to validate it again, it should be a duplicate
+    BOOST_CHECK(chainman->ProcessBlock(block, &new_block));
+    BOOST_CHECK(!new_block);
+}
+
+BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
+{
+    auto test_directory{TestDirectory{"regtest_test_bitcoin_kernel"}};
+
+    auto notifications{std::make_shared<TestKernelNotifications>()};
+    auto context{create_context(notifications, ChainType::REGTEST)};
+
+    // Validate 206 regtest blocks in total.
+    // Stop halfway to check that it is possible to continue validating starting
+    // from prior state.
+    const size_t mid{REGTEST_BLOCK_DATA.size() / 2};
+
+    {
+        auto chainman{create_chainman(test_directory, context)};
+        for (size_t i{0}; i < mid; i++) {
+            Block block{as_bytes(REGTEST_BLOCK_DATA[i])};
+            bool new_block{false};
+            BOOST_CHECK(chainman->ProcessBlock(block, &new_block));
+            BOOST_CHECK(new_block);
+        }
+    }
+
+    auto chainman{create_chainman(test_directory, context)};
+
+    for (size_t i{mid}; i < REGTEST_BLOCK_DATA.size(); i++) {
+        Block block{as_bytes(REGTEST_BLOCK_DATA[i])};
+        bool new_block{false};
+        BOOST_CHECK(chainman->ProcessBlock(block, &new_block));
+        BOOST_CHECK(new_block);
+    }
+}

From 57a2b4047641ec5d7d08ef3a5182669ed8326015 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Mon, 17 Jun 2024 22:50:47 +0200
Subject: [PATCH 10/24] kernel: Add options for reindexing in C header

Adds options for wiping the chainstate and block tree indexes to the
chainstate load options. In combination and once the
`*_import_blocks(...)` function is added in a later commit, this
triggers a reindex. For now, it just wipes the existing data.
---
 src/kernel/bitcoinkernel.cpp       | 13 +++++++
 src/kernel/bitcoinkernel.h         | 13 +++++++
 src/kernel/bitcoinkernel_wrapper.h |  5 +++
 src/test/kernel/test_kernel.cpp    | 55 +++++++++++++++++++++++++++---
 4 files changed, 82 insertions(+), 4 deletions(-)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index acc5cad69ce..972b9cc9441 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -702,6 +702,19 @@ void btck_chainstate_manager_options_destroy(btck_ChainstateManagerOptions* opti
     delete options;
 }
 
+int btck_chainstate_manager_options_set_wipe_dbs(btck_ChainstateManagerOptions* chainman_opts, int wipe_block_tree_db, int wipe_chainstate_db)
+{
+    if (wipe_block_tree_db == 1 && wipe_chainstate_db != 1) {
+        LogError("Wiping the block tree db without also wiping the chainstate db is currently unsupported.");
+        return -1;
+    }
+    auto& opts{btck_ChainstateManagerOptions::get(chainman_opts)};
+    LOCK(opts.m_mutex);
+    opts.m_blockman_options.block_tree_db_params.wipe_data = wipe_block_tree_db == 1;
+    opts.m_chainstate_load_options.wipe_chainstate_db = wipe_chainstate_db == 1;
+    return 0;
+}
+
 btck_ChainstateManager* btck_chainstate_manager_create(
     const btck_ChainstateManagerOptions* chainman_opts)
 {
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index 5c2b51390c5..c871a4b5dfb 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -731,6 +731,19 @@ BITCOINKERNEL_API void btck_chainstate_manager_options_set_worker_threads_num(
     btck_ChainstateManagerOptions* chainstate_manager_options,
     int worker_threads) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Sets wipe db in the options.
+ *
+ * @param[in] chainstate_manager_options Non-null, created by @ref btck_chainstate_manager_options_create.
+ * @param[in] wipe_block_tree_db         Set wipe block tree db. Should only be 1 if wipe_chainstate_db is 1 too.
+ * @param[in] wipe_chainstate_db         Set wipe chainstate db.
+ * @return                               0 if the set was successful, non-zero if the set failed.
+ */
+BITCOINKERNEL_API int btck_chainstate_manager_options_set_wipe_dbs(
+    btck_ChainstateManagerOptions* chainstate_manager_options,
+    int wipe_block_tree_db,
+    int wipe_chainstate_db) BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * Destroy the chainstate manager options.
  */
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index 5ec6fada44d..248a286295a 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -673,6 +673,11 @@ public:
         btck_chainstate_manager_options_set_worker_threads_num(get(), worker_threads);
     }
 
+    bool SetWipeDbs(bool wipe_block_tree, bool wipe_chainstate)
+    {
+        return btck_chainstate_manager_options_set_wipe_dbs(get(), wipe_block_tree, wipe_chainstate) == 0;
+    }
+
     friend class ChainMan;
 };
 
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index d793841120d..e5c0405210c 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -529,18 +529,34 @@ BOOST_AUTO_TEST_CASE(btck_chainman_tests)
 
     ChainstateManagerOptions chainman_opts{context, test_directory.m_directory.string(), (test_directory.m_directory / "blocks").string()};
     chainman_opts.SetWorkerThreads(4);
+    BOOST_CHECK(!chainman_opts.SetWipeDbs(/*wipe_block_tree=*/true, /*wipe_chainstate=*/false));
+    BOOST_CHECK(chainman_opts.SetWipeDbs(/*wipe_block_tree=*/true, /*wipe_chainstate=*/true));
+    BOOST_CHECK(chainman_opts.SetWipeDbs(/*wipe_block_tree=*/false, /*wipe_chainstate=*/true));
+    BOOST_CHECK(chainman_opts.SetWipeDbs(/*wipe_block_tree=*/false, /*wipe_chainstate=*/false));
     ChainMan chainman{context, chainman_opts};
 }
 
 std::unique_ptr<ChainMan> create_chainman(TestDirectory& test_directory,
+                                          bool reindex,
+                                          bool wipe_chainstate,
                                           Context& context)
 {
+    auto mainnet_test_directory{TestDirectory{"mainnet_test_bitcoin_kernel"}};
+
     ChainstateManagerOptions chainman_opts{context, test_directory.m_directory.string(), (test_directory.m_directory / "blocks").string()};
+
+    if (reindex) {
+        chainman_opts.SetWipeDbs(/*wipe_block_tree=*/reindex, /*wipe_chainstate=*/reindex);
+    }
+    if (wipe_chainstate) {
+        chainman_opts.SetWipeDbs(/*wipe_block_tree=*/false, /*wipe_chainstate=*/wipe_chainstate);
+    }
+
     auto chainman{std::make_unique<ChainMan>(context, chainman_opts)};
     return chainman;
 }
 
-BOOST_AUTO_TEST_CASE(btck_chainman_mainnet_tests)
+void chainman_reindex_test(TestDirectory& test_directory)
 {
     btck_LoggingOptions logging_options = {
         .log_timestamps = true,
@@ -555,7 +571,21 @@ BOOST_AUTO_TEST_CASE(btck_chainman_mainnet_tests)
 
     auto notifications{std::make_shared<TestKernelNotifications>()};
     auto context{create_context(notifications, ChainType::MAINNET)};
-    auto chainman{create_chainman(mainnet_test_directory, context)};
+    auto chainman{create_chainman(test_directory, true, false, context)};
+}
+
+void chainman_reindex_chainstate_test(TestDirectory& test_directory)
+{
+    auto notifications{std::make_shared<TestKernelNotifications>()};
+    auto context{create_context(notifications, ChainType::MAINNET)};
+    auto chainman{create_chainman(test_directory, false, true, context)};
+}
+
+void chainman_mainnet_validation_test(TestDirectory& test_directory)
+{
+    auto notifications{std::make_shared<TestKernelNotifications>()};
+    auto context{create_context(notifications, ChainType::MAINNET)};
+    auto chainman{create_chainman(test_directory, false, false, context)};
 
     {
         // Process an invalid block
@@ -591,6 +621,23 @@ BOOST_AUTO_TEST_CASE(btck_chainman_mainnet_tests)
     BOOST_CHECK(!new_block);
 }
 
+BOOST_AUTO_TEST_CASE(btck_chainman_mainnet_tests)
+{
+    btck_LoggingOptions logging_options = {
+        .log_timestamps = true,
+        .log_time_micros = true,
+        .log_threadnames = false,
+        .log_sourcelocations = false,
+        .always_print_category_levels = true,
+    };
+    Logger logger{std::make_unique<TestLog>(TestLog{}), logging_options};
+
+    auto test_directory{TestDirectory{"mainnet_test_bitcoin_kernel"}};
+    chainman_mainnet_validation_test(test_directory);
+    chainman_reindex_test(test_directory);
+    chainman_reindex_chainstate_test(test_directory);
+}
+
 BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
 {
     auto test_directory{TestDirectory{"regtest_test_bitcoin_kernel"}};
@@ -604,7 +651,7 @@ BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
     const size_t mid{REGTEST_BLOCK_DATA.size() / 2};
 
     {
-        auto chainman{create_chainman(test_directory, context)};
+        auto chainman{create_chainman(test_directory, false, false, context)};
         for (size_t i{0}; i < mid; i++) {
             Block block{as_bytes(REGTEST_BLOCK_DATA[i])};
             bool new_block{false};
@@ -613,7 +660,7 @@ BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
         }
     }
 
-    auto chainman{create_chainman(test_directory, context)};
+    auto chainman{create_chainman(test_directory, false, false, context)};
 
     for (size_t i{mid}; i < REGTEST_BLOCK_DATA.size(); i++) {
         Block block{as_bytes(REGTEST_BLOCK_DATA[i])};

From 41f81149c8b43f584192bc9e794189dbb644e6fa Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Sat, 22 Jun 2024 21:08:10 +0200
Subject: [PATCH 11/24] kernel: Add chainstate load options for in-memory dbs
 in C header

This allows a user to run the kernel without creating on-disk files for
the block tree and chainstate indexes. This is potentially useful in
scenarios where the user needs to do some ephemeral validation
operations.

One specific use case is when linearizing the blocks on disk. The block
files store blocks out of order, so a program may utilize the library
and its header to read the blocks with one chainstate manager, and then
write them back in order, and without orphans, with another chainstate
maanger. To save disk resources and if the indexes are not required once
done, it may be beneficial to keep the indexes in memory for the
chainstate manager that writes the blocks back again.
---
 src/kernel/bitcoinkernel.cpp       | 18 +++++++++++++++
 src/kernel/bitcoinkernel.h         | 20 ++++++++++++++++
 src/kernel/bitcoinkernel_wrapper.h | 10 ++++++++
 src/test/kernel/test_kernel.cpp    | 37 ++++++++++++++++++++++++++----
 4 files changed, 80 insertions(+), 5 deletions(-)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index 972b9cc9441..c17ca372130 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -715,6 +715,24 @@ int btck_chainstate_manager_options_set_wipe_dbs(btck_ChainstateManagerOptions*
     return 0;
 }
 
+void btck_chainstate_manager_options_set_block_tree_db_in_memory(
+    btck_ChainstateManagerOptions* chainman_opts,
+    int block_tree_db_in_memory)
+{
+    auto& opts{btck_ChainstateManagerOptions::get(chainman_opts)};
+    LOCK(opts.m_mutex);
+    opts.m_blockman_options.block_tree_db_params.memory_only = block_tree_db_in_memory == 1;
+}
+
+void btck_chainstate_manager_options_set_chainstate_db_in_memory(
+    btck_ChainstateManagerOptions* chainman_opts,
+    int chainstate_db_in_memory)
+{
+    auto& opts{btck_ChainstateManagerOptions::get(chainman_opts)};
+    LOCK(opts.m_mutex);
+    opts.m_chainstate_load_options.coins_db_in_memory = chainstate_db_in_memory == 1;
+}
+
 btck_ChainstateManager* btck_chainstate_manager_create(
     const btck_ChainstateManagerOptions* chainman_opts)
 {
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index c871a4b5dfb..4c804a3a261 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -744,6 +744,26 @@ BITCOINKERNEL_API int btck_chainstate_manager_options_set_wipe_dbs(
     int wipe_block_tree_db,
     int wipe_chainstate_db) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Sets block tree db in memory in the options.
+ *
+ * @param[in] chainstate_manager_options   Non-null, created by @ref btck_chainstate_manager_options_create.
+ * @param[in] block_tree_db_in_memory      Set block tree db in memory.
+ */
+BITCOINKERNEL_API void btck_chainstate_manager_options_set_block_tree_db_in_memory(
+    btck_ChainstateManagerOptions* chainstate_manager_options,
+    int block_tree_db_in_memory) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Sets chainstate db in memory in the options.
+ *
+ * @param[in] chainstate_manager_options Non-null, created by @ref btck_chainstate_manager_options_create.
+ * @param[in] chainstate_db_in_memory    Set chainstate db in memory.
+ */
+BITCOINKERNEL_API void btck_chainstate_manager_options_set_chainstate_db_in_memory(
+    btck_ChainstateManagerOptions* chainstate_manager_options,
+    int chainstate_db_in_memory) BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * Destroy the chainstate manager options.
  */
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index 248a286295a..e5925ffbffb 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -678,6 +678,16 @@ public:
         return btck_chainstate_manager_options_set_wipe_dbs(get(), wipe_block_tree, wipe_chainstate) == 0;
     }
 
+    void SetBlockTreeDbInMemory(bool block_tree_db_in_memory)
+    {
+        btck_chainstate_manager_options_set_block_tree_db_in_memory(get(), block_tree_db_in_memory);
+    }
+
+    void SetChainstateDbInMemory(bool chainstate_db_in_memory)
+    {
+        btck_chainstate_manager_options_set_chainstate_db_in_memory(get(), chainstate_db_in_memory);
+    }
+
     friend class ChainMan;
 };
 
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index e5c0405210c..8f2e2af2ce0 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -539,6 +539,8 @@ BOOST_AUTO_TEST_CASE(btck_chainman_tests)
 std::unique_ptr<ChainMan> create_chainman(TestDirectory& test_directory,
                                           bool reindex,
                                           bool wipe_chainstate,
+                                          bool block_tree_db_in_memory,
+                                          bool chainstate_db_in_memory,
                                           Context& context)
 {
     auto mainnet_test_directory{TestDirectory{"mainnet_test_bitcoin_kernel"}};
@@ -551,6 +553,12 @@ std::unique_ptr<ChainMan> create_chainman(TestDirectory& test_directory,
     if (wipe_chainstate) {
         chainman_opts.SetWipeDbs(/*wipe_block_tree=*/false, /*wipe_chainstate=*/wipe_chainstate);
     }
+    if (block_tree_db_in_memory) {
+        chainman_opts.SetBlockTreeDbInMemory(block_tree_db_in_memory);
+    }
+    if (chainstate_db_in_memory) {
+        chainman_opts.SetChainstateDbInMemory(chainstate_db_in_memory);
+    }
 
     auto chainman{std::make_unique<ChainMan>(context, chainman_opts)};
     return chainman;
@@ -571,21 +579,21 @@ void chainman_reindex_test(TestDirectory& test_directory)
 
     auto notifications{std::make_shared<TestKernelNotifications>()};
     auto context{create_context(notifications, ChainType::MAINNET)};
-    auto chainman{create_chainman(test_directory, true, false, context)};
+    auto chainman{create_chainman(test_directory, true, false, false, false, context)};
 }
 
 void chainman_reindex_chainstate_test(TestDirectory& test_directory)
 {
     auto notifications{std::make_shared<TestKernelNotifications>()};
     auto context{create_context(notifications, ChainType::MAINNET)};
-    auto chainman{create_chainman(test_directory, false, true, context)};
+    auto chainman{create_chainman(test_directory, false, true, false, false, context)};
 }
 
 void chainman_mainnet_validation_test(TestDirectory& test_directory)
 {
     auto notifications{std::make_shared<TestKernelNotifications>()};
     auto context{create_context(notifications, ChainType::MAINNET)};
-    auto chainman{create_chainman(test_directory, false, false, context)};
+    auto chainman{create_chainman(test_directory, false, false, false, false, context)};
 
     {
         // Process an invalid block
@@ -638,6 +646,25 @@ BOOST_AUTO_TEST_CASE(btck_chainman_mainnet_tests)
     chainman_reindex_chainstate_test(test_directory);
 }
 
+BOOST_AUTO_TEST_CASE(btck_chainman_in_memory_tests)
+{
+    auto in_memory_test_directory{TestDirectory{"in-memory_test_bitcoin_kernel"}};
+
+    auto notifications{std::make_shared<TestKernelNotifications>()};
+    auto context{create_context(notifications, ChainType::REGTEST)};
+    auto chainman{create_chainman(in_memory_test_directory, false, false, true, true, context)};
+
+    for (auto& raw_block : REGTEST_BLOCK_DATA) {
+        Block block{as_bytes(raw_block)};
+        bool new_block{false};
+        chainman->ProcessBlock(block, &new_block);
+        BOOST_CHECK(new_block);
+    }
+
+    BOOST_CHECK(!std::filesystem::exists(in_memory_test_directory.m_directory / "blocks" / "index"));
+    BOOST_CHECK(!std::filesystem::exists(in_memory_test_directory.m_directory / "chainstate"));
+}
+
 BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
 {
     auto test_directory{TestDirectory{"regtest_test_bitcoin_kernel"}};
@@ -651,7 +678,7 @@ BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
     const size_t mid{REGTEST_BLOCK_DATA.size() / 2};
 
     {
-        auto chainman{create_chainman(test_directory, false, false, context)};
+        auto chainman{create_chainman(test_directory, false, false, false, false, context)};
         for (size_t i{0}; i < mid; i++) {
             Block block{as_bytes(REGTEST_BLOCK_DATA[i])};
             bool new_block{false};
@@ -660,7 +687,7 @@ BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
         }
     }
 
-    auto chainman{create_chainman(test_directory, false, false, context)};
+    auto chainman{create_chainman(test_directory, false, false, false, false, context)};
 
     for (size_t i{mid}; i < REGTEST_BLOCK_DATA.size(); i++) {
         Block block{as_bytes(REGTEST_BLOCK_DATA[i])};

From 0459e9ac290d690fcb563abcbb981d2924ead175 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Thu, 30 May 2024 11:22:28 +0200
Subject: [PATCH 12/24] kernel: Add import blocks function to C header

Add `btck_import_blocks` to import block data and rebuild indexes. The
function can either reindex all existing block files if the indexes were
previously wiped through the chainstate load options, or import blocks
from a single specified file path.
---
 src/kernel/bitcoinkernel.cpp       | 19 +++++++++++++++++++
 src/kernel/bitcoinkernel.h         | 20 +++++++++++++++++++-
 src/kernel/bitcoinkernel_wrapper.h | 14 ++++++++++++++
 src/test/kernel/test_kernel.cpp    |  7 +++++++
 4 files changed, 59 insertions(+), 1 deletion(-)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index c17ca372130..749bce886e6 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -791,6 +791,25 @@ void btck_chainstate_manager_destroy(btck_ChainstateManager* chainman)
     delete chainman;
 }
 
+int btck_chainstate_manager_import_blocks(btck_ChainstateManager* chainman, const char** block_file_paths_data, size_t* block_file_paths_lens, size_t block_file_paths_data_len)
+{
+    try {
+        std::vector<fs::path> import_files;
+        import_files.reserve(block_file_paths_data_len);
+        for (uint32_t i = 0; i < block_file_paths_data_len; i++) {
+            if (block_file_paths_data[i] != nullptr) {
+                import_files.emplace_back(std::string{block_file_paths_data[i], block_file_paths_lens[i]}.c_str());
+            }
+        }
+        node::ImportBlocks(*btck_ChainstateManager::get(chainman).m_chainman, import_files);
+        btck_ChainstateManager::get(chainman).m_chainman->ActiveChainstate().ForceFlushStateToDisk();
+    } catch (const std::exception& e) {
+        LogError("Failed to import blocks: %s", e.what());
+        return -1;
+    }
+    return 0;
+}
+
 btck_Block* btck_block_create(const void* raw_block, size_t raw_block_length)
 {
     auto block{std::make_shared<CBlock>()};
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index 4c804a3a261..fca29831510 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -732,7 +732,9 @@ BITCOINKERNEL_API void btck_chainstate_manager_options_set_worker_threads_num(
     int worker_threads) BITCOINKERNEL_ARG_NONNULL(1);
 
 /**
- * @brief Sets wipe db in the options.
+ * @brief Sets wipe db in the options. In combination with calling
+ * @ref btck_chainstate_manager_import_blocks this triggers either a full reindex,
+ * or a reindex of just the chainstate database.
  *
  * @param[in] chainstate_manager_options Non-null, created by @ref btck_chainstate_manager_options_create.
  * @param[in] wipe_block_tree_db         Set wipe block tree db. Should only be 1 if wipe_chainstate_db is 1 too.
@@ -787,6 +789,22 @@ BITCOINKERNEL_API void btck_chainstate_manager_options_destroy(btck_ChainstateMa
 BITCOINKERNEL_API btck_ChainstateManager* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_create(
     const btck_ChainstateManagerOptions* chainstate_manager_options) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Triggers the start of a reindex if the option was previously set for
+ * the chainstate and block manager. Can also import an array of existing block
+ * files selected by the user.
+ *
+ * @param[in] chainstate_manager        Non-null.
+ * @param[in] block_file_paths_data     Nullable, array of block files described by their full filesystem paths.
+ * @param[in] block_file_paths_lens     Nullable, array containing the lengths of each of the paths.
+ * @param[in] block_file_paths_data_len Length of the block_file_paths_data and block_file_paths_len arrays.
+ * @return                              0 if the import blocks call was completed successfully, non-zero otherwise.
+ */
+BITCOINKERNEL_API int btck_chainstate_manager_import_blocks(
+    btck_ChainstateManager* chainstate_manager,
+    const char** block_file_paths_data, size_t* block_file_paths_lens,
+    size_t block_file_paths_data_len) BITCOINKERNEL_ARG_NONNULL(1, 2);
+
 /**
  * @brief Process and validate the passed in block with the chainstate
  * manager. Processing first does checks on the block, and if these passed,
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index e5925ffbffb..b1c943fb2e0 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -699,6 +699,20 @@ public:
     {
     }
 
+    bool ImportBlocks(const std::span<const std::string> paths)
+    {
+        std::vector<const char*> c_paths;
+        std::vector<size_t> c_paths_lens;
+        c_paths.reserve(paths.size());
+        c_paths_lens.reserve(paths.size());
+        for (const auto& path : paths) {
+            c_paths.push_back(path.c_str());
+            c_paths_lens.push_back(path.length());
+        }
+
+        return btck_chainstate_manager_import_blocks(get(), c_paths.data(), c_paths_lens.data(), c_paths.size()) == 0;
+    }
+
     bool ProcessBlock(const Block& block, bool* new_block)
     {
         int _new_block;
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index 8f2e2af2ce0..894b94ebd9c 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -580,6 +580,9 @@ void chainman_reindex_test(TestDirectory& test_directory)
     auto notifications{std::make_shared<TestKernelNotifications>()};
     auto context{create_context(notifications, ChainType::MAINNET)};
     auto chainman{create_chainman(test_directory, true, false, false, false, context)};
+
+    std::vector<std::string> import_files;
+    BOOST_CHECK(chainman->ImportBlocks(import_files));
 }
 
 void chainman_reindex_chainstate_test(TestDirectory& test_directory)
@@ -587,6 +590,10 @@ void chainman_reindex_chainstate_test(TestDirectory& test_directory)
     auto notifications{std::make_shared<TestKernelNotifications>()};
     auto context{create_context(notifications, ChainType::MAINNET)};
     auto chainman{create_chainman(test_directory, false, true, false, false, context)};
+
+    std::vector<std::string> import_files;
+    import_files.push_back((test_directory.m_directory / "blocks" / "blk00000.dat").string());
+    BOOST_CHECK(chainman->ImportBlocks(import_files));
 }
 
 void chainman_mainnet_validation_test(TestDirectory& test_directory)

From 8d9088c5db7a71d80a93ec7d49e36bd420805ff4 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Wed, 5 Jun 2024 10:20:40 +0200
Subject: [PATCH 13/24] kernel: Add interrupt function to C header

Calling interrupt can halt long-running functions associated with
objects that were created through the passed-in context.
---
 src/kernel/bitcoinkernel.cpp       |  5 +++++
 src/kernel/bitcoinkernel.h         | 10 ++++++++++
 src/kernel/bitcoinkernel_wrapper.h |  5 +++++
 src/test/kernel/test_kernel.cpp    |  2 ++
 4 files changed, 22 insertions(+)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index 749bce886e6..91e105980be 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -672,6 +672,11 @@ btck_Context* btck_context_copy(const btck_Context* context)
     return btck_Context::copy(context);
 }
 
+int btck_context_interrupt(btck_Context* context)
+{
+    return (*btck_Context::get(context)->m_interrupt)() ? 0 : -1;
+}
+
 void btck_context_destroy(btck_Context* context)
 {
     delete context;
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index fca29831510..d5eb1c2aaf1 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -689,6 +689,16 @@ BITCOINKERNEL_API btck_Context* BITCOINKERNEL_WARN_UNUSED_RESULT btck_context_cr
 BITCOINKERNEL_API btck_Context* BITCOINKERNEL_WARN_UNUSED_RESULT btck_context_copy(
     const btck_Context* context) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Interrupt can be used to halt long-running validation functions like
+ * when reindexing, importing or processing blocks.
+ *
+ * @param[in] context  Non-null.
+ * @return             0 if the interrupt was successfully, non-zero otherwise.
+ */
+BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_context_interrupt(
+    btck_Context* context) BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * Destroy the context.
  */
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index b1c943fb2e0..ff9f1b74645 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -657,6 +657,11 @@ public:
     Context()
         : Handle{btck_context_create(ContextOptions{}.get())} {}
 
+    bool interrupt()
+    {
+        return btck_context_interrupt(get()) == 0;
+    }
+
     friend class ChainstateManagerOptions;
 };
 
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index 894b94ebd9c..e27eca6dbf7 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -670,6 +670,8 @@ BOOST_AUTO_TEST_CASE(btck_chainman_in_memory_tests)
 
     BOOST_CHECK(!std::filesystem::exists(in_memory_test_directory.m_directory / "blocks" / "index"));
     BOOST_CHECK(!std::filesystem::exists(in_memory_test_directory.m_directory / "chainstate"));
+
+    BOOST_CHECK(context.interrupt());
 }
 
 BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)

From 403fb9b1209e4797077011d248893c83bc7fa253 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Thu, 30 May 2024 22:59:48 +0200
Subject: [PATCH 14/24] kernel: Add validation interface to C header

This adds the infrastructure required to process validation events. For
now the external validation interface only has support for the
`BlockChecked` , `NewPoWValidBlock`, `BlockConnected`, and
`BlockDisconnected` callback. Support for the other internal
validation interface methods can be added in the future.

The validation interface follows an architecture for defining its
callbacks and ownership that is similar to the notifications.

The task runner is created internally with a context, which itself
internally creates a unique ValidationSignals object. When the user
creates a new chainstate manager the validation signals are internally
passed to the chainstate manager through the context.

The callbacks block any further validation execution when they are
called. It is up to the user to either multiplex them, or use them
otherwise in a multithreaded mechanism to make processing the validation
events non-blocking.

A validation interface can register for validation events with a
context. Internally the passed in validation interface is registerd with
the validation signals of a context.
---
 src/kernel/bitcoinkernel.cpp       | 85 +++++++++++++++++++++++++++++-
 src/kernel/bitcoinkernel.h         | 60 ++++++++++++++++++++-
 src/kernel/bitcoinkernel_wrapper.h | 47 +++++++++++++++++
 src/test/kernel/test_kernel.cpp    | 32 ++++++++++-
 4 files changed, 219 insertions(+), 5 deletions(-)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index 91e105980be..8b7bc8726fd 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -31,8 +31,10 @@
 #include <util/fs.h>
 #include <util/result.h>
 #include <util/signalinterrupt.h>
+#include <util/task_runner.h>
 #include <util/translation.h>
 #include <validation.h>
+#include <validationinterface.h>
 
 #include <cassert>
 #include <cstddef>
@@ -47,6 +49,8 @@
 #include <utility>
 #include <vector>
 
+using util::ImmediateTaskRunner;
+
 // Define G_TRANSLATION_FUN symbol in libbitcoinkernel library so users of the
 // library aren't required to export this symbol
 extern const std::function<std::string(const char*)> G_TRANSLATION_FUN{nullptr};
@@ -135,6 +139,7 @@ struct Handle {
 
 struct btck_BlockTreeEntry: Handle<btck_BlockTreeEntry, CBlockIndex> {};
 struct btck_Block : Handle<btck_Block, std::shared_ptr<const CBlock>> {};
+struct btck_BlockValidationState : Handle<btck_BlockValidationState, BlockValidationState> {};
 
 namespace {
 
@@ -326,10 +331,65 @@ public:
     }
 };
 
+class KernelValidationInterface final : public CValidationInterface
+{
+public:
+    btck_ValidationInterfaceCallbacks m_cbs;
+
+    explicit KernelValidationInterface(const btck_ValidationInterfaceCallbacks vi_cbs) : m_cbs{vi_cbs} {}
+
+    ~KernelValidationInterface()
+    {
+        if (m_cbs.user_data && m_cbs.user_data_destroy) {
+            m_cbs.user_data_destroy(m_cbs.user_data);
+        }
+        m_cbs.user_data = nullptr;
+        m_cbs.user_data_destroy = nullptr;
+    }
+
+protected:
+    void BlockChecked(const std::shared_ptr<const CBlock>& block, const BlockValidationState& stateIn) override
+    {
+        if (m_cbs.block_checked) {
+            m_cbs.block_checked(m_cbs.user_data,
+                                btck_Block::ref(new std::shared_ptr<const CBlock>{block}),
+                                btck_BlockValidationState::ref(&stateIn));
+        }
+    }
+
+    void NewPoWValidBlock(const CBlockIndex* pindex, const std::shared_ptr<const CBlock>& block) override
+    {
+        if (m_cbs.pow_valid_block) {
+            m_cbs.pow_valid_block(m_cbs.user_data,
+                                  btck_BlockTreeEntry::ref(pindex),
+                                  btck_Block::ref(new std::shared_ptr<const CBlock>{block}));
+        }
+    }
+
+    void BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override
+    {
+        if (m_cbs.block_connected) {
+            m_cbs.block_connected(m_cbs.user_data,
+                                  btck_Block::ref(new std::shared_ptr<const CBlock>{block}),
+                                  btck_BlockTreeEntry::ref(pindex));
+        }
+    }
+
+    void BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override
+    {
+        if (m_cbs.block_disconnected) {
+            m_cbs.block_disconnected(m_cbs.user_data,
+                                     btck_Block::ref(new std::shared_ptr<const CBlock>{block}),
+                                     btck_BlockTreeEntry::ref(pindex));
+        }
+    }
+};
+
 struct ContextOptions {
     mutable Mutex m_mutex;
     std::unique_ptr<const CChainParams> m_chainparams GUARDED_BY(m_mutex);
     std::shared_ptr<KernelNotifications> m_notifications GUARDED_BY(m_mutex);
+    std::shared_ptr<KernelValidationInterface> m_validation_interface GUARDED_BY(m_mutex);
 };
 
 class Context
@@ -341,11 +401,16 @@ public:
 
     std::unique_ptr<util::SignalInterrupt> m_interrupt;
 
+    std::unique_ptr<ValidationSignals> m_signals;
+
     std::unique_ptr<const CChainParams> m_chainparams;
 
+    std::shared_ptr<KernelValidationInterface> m_validation_interface;
+
     Context(const ContextOptions* options, bool& sane)
         : m_context{std::make_unique<kernel::Context>()},
-          m_interrupt{std::make_unique<util::SignalInterrupt>()}
+          m_interrupt{std::make_unique<util::SignalInterrupt>()},
+          m_signals{std::make_unique<ValidationSignals>(std::make_unique<ImmediateTaskRunner>())}
     {
         if (options) {
             LOCK(options->m_mutex);
@@ -355,6 +420,10 @@ public:
             if (options->m_notifications) {
                 m_notifications = options->m_notifications;
             }
+            if (options->m_validation_interface) {
+                m_validation_interface = options->m_validation_interface;
+                m_signals->RegisterSharedValidationInterface(m_validation_interface);
+            }
         }
 
         if (!m_chainparams) {
@@ -369,6 +438,11 @@ public:
             sane = false;
         }
     }
+
+    ~Context()
+    {
+        m_signals->UnregisterSharedValidationInterface(m_validation_interface);
+    }
 };
 
 //! Helper struct to wrap the ChainstateManager-related Options
@@ -383,7 +457,8 @@ struct ChainstateManagerOptions {
         : m_chainman_options{ChainstateManager::Options{
               .chainparams = *context->m_chainparams,
               .datadir = data_dir,
-              .notifications = *context->m_notifications}},
+              .notifications = *context->m_notifications,
+              .signals = context->m_signals.get()}},
           m_blockman_options{node::BlockManager::Options{
               .chainparams = *context->m_chainparams,
               .blocks_dir = blocks_dir,
@@ -650,6 +725,12 @@ void btck_context_options_set_notifications(btck_ContextOptions* options, btck_N
     btck_ContextOptions::get(options).m_notifications = std::make_shared<KernelNotifications>(notifications);
 }
 
+void btck_context_options_set_validation_interface(btck_ContextOptions* options, btck_ValidationInterfaceCallbacks vi_cbs)
+{
+    LOCK(btck_ContextOptions::get(options).m_mutex);
+    btck_ContextOptions::get(options).m_validation_interface = std::make_shared<KernelValidationInterface>(vi_cbs);
+}
+
 void btck_context_options_destroy(btck_ContextOptions* options)
 {
     delete options;
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index d5eb1c2aaf1..67ef952ada7 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -67,6 +67,9 @@ extern "C" {
  * functions, e.g. for scripts, may communicate more detailed error information
  * through status code out parameters.
  *
+ * Fine-grained validation information is communicated through the validation
+ * interface.
+ *
  * The kernel notifications issue callbacks for errors. These are usually
  * indicative of a system error. If such an error is issued, it is recommended
  * to halt and tear down the existing kernel objects. Remediating the error may
@@ -148,6 +151,10 @@ typedef struct btck_ContextOptions btck_ContextOptions;
  * other validation objects are instantiated from it, the context is kept in
  * memory for the duration of their lifetimes.
  *
+ * The processing of validation events is done through an internal task runner
+ * owned by the context. It passes events through the registered validation
+ * interface callbacks.
+ *
  * A constructed context can be safely used from multiple threads.
  */
 typedef struct btck_Context btck_Context;
@@ -190,6 +197,14 @@ typedef struct btck_ChainstateManager btck_ChainstateManager;
  */
 typedef struct btck_Block btck_Block;
 
+/**
+ * Opaque data structure for holding the state of a block during validation.
+ *
+ * Contains information indicating whether validation was successful, and if not
+ * which step during block validation failed.
+ */
+typedef struct btck_BlockValidationState btck_BlockValidationState;
+
 /** Current sync state passed to tip changed callbacks. */
 typedef uint8_t btck_SynchronizationState;
 #define btck_SynchronizationState_INIT_REINDEX ((btck_SynchronizationState)(0))
@@ -225,6 +240,33 @@ typedef void (*btck_NotifyWarningUnset)(void* user_data, btck_Warning warning);
 typedef void (*btck_NotifyFlushError)(void* user_data, const char* message, size_t message_len);
 typedef void (*btck_NotifyFatalError)(void* user_data, const char* message, size_t message_len);
 
+/**
+ * Function signatures for the validation interface.
+ */
+typedef void (*btck_ValidationInterfaceBlockChecked)(void* user_data, btck_Block* block, const btck_BlockValidationState* state);
+typedef void (*btck_ValidationInterfacePowValidBlock)(void* user_data, const btck_BlockTreeEntry* entry, btck_Block* block);
+typedef void (*btck_ValidationInterfaceBlockConnected)(void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry);
+typedef void (*btck_ValidationInterfaceBlockDisconnected)(void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry);
+
+/**
+ * Holds the validation interface callbacks. The user data pointer may be used
+ * to point to user-defined structures to make processing the validation
+ * callbacks easier. Note that these callbacks block any further validation
+ * execution when they are called.
+ */
+typedef struct {
+    void* user_data;                                              //!< Holds a user-defined opaque structure that is passed to the validation
+                                                                  //!< interface callbacks. If user_data_destroy is also defined ownership of the
+                                                                  //!< user_data is passed to the created context options and subsequently context.
+    btck_DestroyCallback user_data_destroy;                       //!< Frees the provided user data structure.
+    btck_ValidationInterfaceBlockChecked block_checked;           //!< Called when a new block has been fully validated. Contains the
+                                                                  //!< result of its validation.
+    btck_ValidationInterfacePowValidBlock pow_valid_block;        //!< Called when a new block extends the header chain and has a valid transaction
+                                                                  //!< and segwit merkle root.
+    btck_ValidationInterfaceBlockConnected block_connected;       //!< Called when a block is valid and has now been connected to the best chain.
+    btck_ValidationInterfaceBlockDisconnected block_disconnected; //!< Called during a re-org when a block has been removed from the best chain.
+} btck_ValidationInterfaceCallbacks;
+
 /**
  * A struct for holding the kernel notification callbacks. The user data
  * pointer may be used to point to user-defined structures to make processing
@@ -659,6 +701,20 @@ BITCOINKERNEL_API void btck_context_options_set_notifications(
     btck_ContextOptions* context_options,
     btck_NotificationInterfaceCallbacks notifications) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Set the validation interface callbacks for the context options. The
+ * context created with the options will be configured for these validation
+ * interface callbacks. The callbacks will then be triggered from validation
+ * events issued by the chainstate manager created from the same context.
+ *
+ * @param[in] context_options                Non-null, previously created with btck_context_options_create.
+ * @param[in] validation_interface_callbacks The callbacks used for passing validation information to the
+ *                                           user.
+ */
+BITCOINKERNEL_API void btck_context_options_set_validation_interface(
+    btck_ContextOptions* context_options,
+    btck_ValidationInterfaceCallbacks validation_interface_callbacks) BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * Destroy the context options.
  */
@@ -820,7 +876,9 @@ BITCOINKERNEL_API int btck_chainstate_manager_import_blocks(
  * manager. Processing first does checks on the block, and if these passed,
  * saves it to disk. It then validates the block against the utxo set. If it is
  * valid, the chain is extended with it. The return value is not indicative of
- * the block's validity.
+ * the block's validity. Detailed information on the validity of the block can
+ * be retrieved by registering the `block_checked` callback in the validation
+ * interface.
  *
  * @param[in] chainstate_manager Non-null.
  * @param[in] block              Non-null, block to be validated.
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index ff9f1b74645..be90788b8ec 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -605,6 +605,35 @@ public:
     virtual void FatalErrorHandler(std::string_view error) {}
 };
 
+class BlockValidationState
+{
+private:
+    const btck_BlockValidationState* m_state;
+
+public:
+    BlockValidationState(const btck_BlockValidationState* state) : m_state{state} {}
+
+    BlockValidationState(const BlockValidationState&) = delete;
+    BlockValidationState& operator=(const BlockValidationState&) = delete;
+    BlockValidationState(BlockValidationState&&) = delete;
+    BlockValidationState& operator=(BlockValidationState&&) = delete;
+};
+
+template <typename T>
+class ValidationInterface
+{
+public:
+    virtual ~ValidationInterface() = default;
+
+    virtual void BlockChecked(Block block, const BlockValidationState state) {}
+
+    virtual void PowValidBlock(BlockTreeEntry entry, Block block) {}
+
+    virtual void BlockConnected(Block block, BlockTreeEntry entry) {}
+
+    virtual void BlockDisconnected(Block block, BlockTreeEntry entry) {}
+};
+
 class ChainParams : public Handle<btck_ChainParameters, btck_chain_parameters_copy, btck_chain_parameters_destroy>
 {
 public:
@@ -645,6 +674,24 @@ public:
             });
     }
 
+    template <typename T>
+    void SetValidationInterface(std::shared_ptr<T> validation_interface)
+    {
+        static_assert(std::is_base_of_v<ValidationInterface<T>, T>);
+        auto heap_vi = std::make_unique<std::shared_ptr<T>>(std::move(validation_interface));
+        using user_type = std::shared_ptr<T>*;
+        btck_context_options_set_validation_interface(
+            get(),
+            btck_ValidationInterfaceCallbacks{
+                .user_data = heap_vi.release(),
+                .user_data_destroy = +[](void* user_data) { delete static_cast<user_type>(user_data); },
+                .block_checked = +[](void* user_data, btck_Block* block, const btck_BlockValidationState* state) { (*static_cast<user_type>(user_data))->BlockChecked(Block{block}, BlockValidationState{state}); },
+                .pow_valid_block = +[](void* user_data, const btck_BlockTreeEntry* entry, btck_Block* block) { (*static_cast<user_type>(user_data))->PowValidBlock(BlockTreeEntry{entry}, Block{block}); },
+                .block_connected = +[](void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry) { (*static_cast<user_type>(user_data))->BlockConnected(Block{block}, BlockTreeEntry{entry}); },
+                .block_disconnected = +[](void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry) { (*static_cast<user_type>(user_data))->BlockDisconnected(Block{block}, BlockTreeEntry{entry}); },
+            });
+    }
+
     friend class Context;
 };
 
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index e27eca6dbf7..3fdc7d3f13b 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -131,6 +131,30 @@ public:
     }
 };
 
+class TestValidationInterface : public ValidationInterface<TestValidationInterface>
+{
+public:
+    void BlockChecked(Block block, const BlockValidationState state) override
+    {
+        std::cout << "Block checked." << std::endl;
+    }
+
+    void BlockConnected(Block block, BlockTreeEntry entry) override
+    {
+        std::cout << "Block connected." << std::endl;
+    }
+
+    void PowValidBlock(BlockTreeEntry entry, Block block) override
+    {
+        std::cout << "Block passed pow verification" << std::endl;
+    }
+
+    void BlockDisconnected(Block block, BlockTreeEntry entry) override
+    {
+        std::cout << "Block disconnected." << std::endl;
+    }
+};
+
 void run_verify_test(
     const ScriptPubkey& spent_script_pubkey,
     const Transaction& spending_tx,
@@ -489,12 +513,15 @@ BOOST_AUTO_TEST_CASE(btck_block)
     CheckRange(block_tx.Transactions(), block_tx.CountTransactions());
 }
 
-Context create_context(std::shared_ptr<TestKernelNotifications> notifications, ChainType chain_type)
+Context create_context(std::shared_ptr<TestKernelNotifications> notifications, ChainType chain_type, std::shared_ptr<TestValidationInterface> validation_interface = nullptr)
 {
     ContextOptions options{};
     ChainParams params{chain_type};
     options.SetChainParams(params);
     options.SetNotifications(notifications);
+    if (validation_interface) {
+        options.SetValidationInterface(validation_interface);
+    }
     auto context{Context{options}};
     return context;
 }
@@ -599,7 +626,8 @@ void chainman_reindex_chainstate_test(TestDirectory& test_directory)
 void chainman_mainnet_validation_test(TestDirectory& test_directory)
 {
     auto notifications{std::make_shared<TestKernelNotifications>()};
-    auto context{create_context(notifications, ChainType::MAINNET)};
+    auto validation_interface{std::make_shared<TestValidationInterface>()};
+    auto context{create_context(notifications, ChainType::MAINNET, validation_interface)};
     auto chainman{create_chainman(test_directory, false, false, false, false, context)};
 
     {

From fbbec31efcc6a10bac393ff746c11730f522948d Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Fri, 31 May 2024 13:34:00 +0200
Subject: [PATCH 15/24] kernel: Add functions for the block validation state to
 C header

These allow for the interpretation of the data in a `BlockChecked`
validation interface callback. The validation state passed through
`BlockChecked` is the source of truth for the validity of a block (the
mode). It is
also useful to get richer information in case a block failed to
validate (the result).
---
 src/kernel/bitcoinkernel.cpp       | 34 +++++++++++++++++++++
 src/kernel/bitcoinkernel.h         | 42 ++++++++++++++++++++++++++
 src/kernel/bitcoinkernel_wrapper.h | 28 +++++++++++++++++
 src/test/kernel/test_kernel.cpp    | 48 +++++++++++++++++++++++++++++-
 4 files changed, 151 insertions(+), 1 deletion(-)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index 8b7bc8726fd..1f9c7d647af 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -763,6 +763,40 @@ void btck_context_destroy(btck_Context* context)
     delete context;
 }
 
+btck_ValidationMode btck_block_validation_state_get_validation_mode(const btck_BlockValidationState* block_validation_state_)
+{
+    auto& block_validation_state = btck_BlockValidationState::get(block_validation_state_);
+    if (block_validation_state.IsValid()) return btck_ValidationMode_VALID;
+    if (block_validation_state.IsInvalid()) return btck_ValidationMode_INVALID;
+    return btck_ValidationMode_INTERNAL_ERROR;
+}
+
+btck_BlockValidationResult btck_block_validation_state_get_block_validation_result(const btck_BlockValidationState* block_validation_state_)
+{
+    auto& block_validation_state = btck_BlockValidationState::get(block_validation_state_);
+    switch (block_validation_state.GetResult()) {
+    case BlockValidationResult::BLOCK_RESULT_UNSET:
+        return btck_BlockValidationResult_UNSET;
+    case BlockValidationResult::BLOCK_CONSENSUS:
+        return btck_BlockValidationResult_CONSENSUS;
+    case BlockValidationResult::BLOCK_CACHED_INVALID:
+        return btck_BlockValidationResult_CACHED_INVALID;
+    case BlockValidationResult::BLOCK_INVALID_HEADER:
+        return btck_BlockValidationResult_INVALID_HEADER;
+    case BlockValidationResult::BLOCK_MUTATED:
+        return btck_BlockValidationResult_MUTATED;
+    case BlockValidationResult::BLOCK_MISSING_PREV:
+        return btck_BlockValidationResult_MISSING_PREV;
+    case BlockValidationResult::BLOCK_INVALID_PREV:
+        return btck_BlockValidationResult_INVALID_PREV;
+    case BlockValidationResult::BLOCK_TIME_FUTURE:
+        return btck_BlockValidationResult_TIME_FUTURE;
+    case BlockValidationResult::BLOCK_HEADER_LOW_WORK:
+        return btck_BlockValidationResult_HEADER_LOW_WORK;
+    } // no default case, so the compiler can warn about missing cases
+    assert(false);
+}
+
 btck_ChainstateManagerOptions* btck_chainstate_manager_options_create(const btck_Context* context, const char* data_dir, size_t data_dir_len, const char* blocks_dir, size_t blocks_dir_len)
 {
     try {
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index 67ef952ada7..362dbaedba0 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -248,6 +248,29 @@ typedef void (*btck_ValidationInterfacePowValidBlock)(void* user_data, const btc
 typedef void (*btck_ValidationInterfaceBlockConnected)(void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry);
 typedef void (*btck_ValidationInterfaceBlockDisconnected)(void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry);
 
+/**
+ * Whether a validated data structure is valid, invalid, or an error was
+ * encountered during processing.
+ */
+typedef uint8_t btck_ValidationMode;
+#define btck_ValidationMode_VALID ((btck_ValidationMode)(0))
+#define btck_ValidationMode_INVALID ((btck_ValidationMode)(1))
+#define btck_ValidationMode_INTERNAL_ERROR ((btck_ValidationMode)(2))
+
+/**
+ * A granular "reason" why a block was invalid.
+ */
+typedef uint32_t btck_BlockValidationResult;
+#define btck_BlockValidationResult_UNSET ((btck_BlockValidationResult)(0))           //!< initial value. Block has not yet been rejected
+#define btck_BlockValidationResult_CONSENSUS ((btck_BlockValidationResult)(1))       //!< invalid by consensus rules (excluding any below reasons)
+#define btck_BlockValidationResult_CACHED_INVALID ((btck_BlockValidationResult)(2))  //!< this block was cached as being invalid and we didn't store the reason why
+#define btck_BlockValidationResult_INVALID_HEADER ((btck_BlockValidationResult)(3))  //!< invalid proof of work or time too old
+#define btck_BlockValidationResult_MUTATED ((btck_BlockValidationResult)(4))         //!< the block's data didn't match the data committed to by the PoW
+#define btck_BlockValidationResult_MISSING_PREV ((btck_BlockValidationResult)(5))    //!< We don't have the previous block the checked one is built on
+#define btck_BlockValidationResult_INVALID_PREV ((btck_BlockValidationResult)(6))    //!< A block this one builds on is invalid
+#define btck_BlockValidationResult_TIME_FUTURE ((btck_BlockValidationResult)(7))     //!< block timestamp was > 2 hours in the future (or our clock is bad)
+#define btck_BlockValidationResult_HEADER_LOW_WORK ((btck_BlockValidationResult)(8)) //!< the block header may be on a too-little-work chain
+
 /**
  * Holds the validation interface callbacks. The user data pointer may be used
  * to point to user-defined structures to make processing the validation
@@ -949,6 +972,25 @@ BITCOINKERNEL_API void btck_block_destroy(btck_Block* block);
 
 ///@}
 
+/** @name BlockValidationState
+ * Functions for working with block validation states.
+ */
+///@{
+
+/**
+ * Returns the validation mode from an opaque block validation state pointer.
+ */
+BITCOINKERNEL_API btck_ValidationMode btck_block_validation_state_get_validation_mode(
+    const btck_BlockValidationState* block_validation_state) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Returns the validation result from an opaque block validation state pointer.
+ */
+BITCOINKERNEL_API btck_BlockValidationResult btck_block_validation_state_get_block_validation_result(
+    const btck_BlockValidationState* block_validation_state) BITCOINKERNEL_ARG_NONNULL(1);
+
+///@}
+
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index be90788b8ec..058bf25d361 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -61,6 +61,24 @@ enum class Warning : btck_Warning {
     LARGE_WORK_INVALID_CHAIN = btck_Warning_LARGE_WORK_INVALID_CHAIN
 };
 
+enum class ValidationMode : btck_ValidationMode {
+    VALID = btck_ValidationMode_VALID,
+    INVALID = btck_ValidationMode_INVALID,
+    INTERNAL_ERROR = btck_ValidationMode_INTERNAL_ERROR
+};
+
+enum class BlockValidationResult : btck_BlockValidationResult {
+    UNSET = btck_BlockValidationResult_UNSET,
+    CONSENSUS = btck_BlockValidationResult_CONSENSUS,
+    CACHED_INVALID = btck_BlockValidationResult_CACHED_INVALID,
+    INVALID_HEADER = btck_BlockValidationResult_INVALID_HEADER,
+    MUTATED = btck_BlockValidationResult_MUTATED,
+    MISSING_PREV = btck_BlockValidationResult_MISSING_PREV,
+    INVALID_PREV = btck_BlockValidationResult_INVALID_PREV,
+    TIME_FUTURE = btck_BlockValidationResult_TIME_FUTURE,
+    HEADER_LOW_WORK = btck_BlockValidationResult_HEADER_LOW_WORK
+};
+
 enum class ScriptVerifyStatus : btck_ScriptVerifyStatus {
     OK = btck_ScriptVerifyStatus_SCRIPT_VERIFY_OK,
     ERROR_INVALID_FLAGS_COMBINATION = btck_ScriptVerifyStatus_ERROR_INVALID_FLAGS_COMBINATION,
@@ -617,6 +635,16 @@ public:
     BlockValidationState& operator=(const BlockValidationState&) = delete;
     BlockValidationState(BlockValidationState&&) = delete;
     BlockValidationState& operator=(BlockValidationState&&) = delete;
+
+    ValidationMode GetValidationMode() const
+    {
+        return static_cast<ValidationMode>(btck_block_validation_state_get_validation_mode(m_state));
+    }
+
+    BlockValidationResult GetBlockValidationResult() const
+    {
+        return static_cast<BlockValidationResult>(btck_block_validation_state_get_block_validation_result(m_state));
+    }
 };
 
 template <typename T>
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index 3fdc7d3f13b..df4fd4104ac 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -136,7 +136,53 @@ class TestValidationInterface : public ValidationInterface<TestValidationInterfa
 public:
     void BlockChecked(Block block, const BlockValidationState state) override
     {
-        std::cout << "Block checked." << std::endl;
+        std::cout << "Block checked: ";
+
+        auto mode{state.GetValidationMode()};
+        switch (mode) {
+        case ValidationMode::VALID: {
+            std::cout << "Valid block" << std::endl;
+            return;
+        }
+        case ValidationMode::INVALID: {
+            std::cout << "Invalid block: ";
+            auto result{state.GetBlockValidationResult()};
+            switch (result) {
+            case BlockValidationResult::UNSET:
+                std::cout << "initial value. Block has not yet been rejected" << std::endl;
+                break;
+            case BlockValidationResult::HEADER_LOW_WORK:
+                std::cout << "the block header may be on a too-little-work chain" << std::endl;
+                break;
+            case BlockValidationResult::CONSENSUS:
+                std::cout << "invalid by consensus rules (excluding any below reasons)" << std::endl;
+                break;
+            case BlockValidationResult::CACHED_INVALID:
+                std::cout << "this block was cached as being invalid and we didn't store the reason why" << std::endl;
+                break;
+            case BlockValidationResult::INVALID_HEADER:
+                std::cout << "invalid proof of work or time too old" << std::endl;
+                break;
+            case BlockValidationResult::MUTATED:
+                std::cout << "the block's data didn't match the data committed to by the PoW" << std::endl;
+                break;
+            case BlockValidationResult::MISSING_PREV:
+                std::cout << "We don't have the previous block the checked one is built on" << std::endl;
+                break;
+            case BlockValidationResult::INVALID_PREV:
+                std::cout << "A block this one builds on is invalid" << std::endl;
+                break;
+            case BlockValidationResult::TIME_FUTURE:
+                std::cout << "block timestamp was > 2 hours in the future (or our clock is bad)" << std::endl;
+                break;
+            }
+            return;
+        }
+        case ValidationMode::INTERNAL_ERROR: {
+            std::cout << "Internal error" << std::endl;
+            return;
+        }
+        }
     }
 
     void BlockConnected(Block block, BlockTreeEntry entry) override

From e3d4d2461e34e1bbd5a425b5810d2537cbdbe96a Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Sat, 1 Jun 2024 11:52:52 +0200
Subject: [PATCH 16/24] kernel: Add function for copying block data to C header

This adds a function for streaming bytes into a user-owned data
structure.

Use it in the tests for verifying the implementation of the validation
interface's `BlockChecked` method.
---
 src/kernel/bitcoinkernel.cpp       | 11 +++++++++++
 src/kernel/bitcoinkernel.h         | 25 ++++++++++++++++++++-----
 src/kernel/bitcoinkernel_wrapper.h |  5 +++++
 src/test/kernel/test_kernel.cpp    | 24 +++++++++++++++++++++---
 4 files changed, 57 insertions(+), 8 deletions(-)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index 1f9c7d647af..ee22337d0e7 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -962,6 +962,17 @@ const btck_Transaction* btck_block_get_transaction_at(const btck_Block* block, s
     return btck_Transaction::ref(&btck_Block::get(block)->vtx[index]);
 }
 
+int btck_block_to_bytes(const btck_Block* block, btck_WriteBytes writer, void* user_data)
+{
+    try {
+        WriterStream ws{writer, user_data};
+        ws << TX_WITH_WITNESS(*btck_Block::get(block));
+        return 0;
+    } catch (...) {
+        return -1;
+    }
+}
+
 void btck_block_destroy(btck_Block* block)
 {
     delete block;
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index 362dbaedba0..ce87db1649a 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -248,6 +248,11 @@ typedef void (*btck_ValidationInterfacePowValidBlock)(void* user_data, const btc
 typedef void (*btck_ValidationInterfaceBlockConnected)(void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry);
 typedef void (*btck_ValidationInterfaceBlockDisconnected)(void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry);
 
+/**
+ * Function signature for serializing data.
+ */
+typedef int (*btck_WriteBytes)(const void* bytes, size_t size, void* userdata);
+
 /**
  * Whether a validated data structure is valid, invalid, or an error was
  * encountered during processing.
@@ -384,11 +389,6 @@ typedef uint8_t btck_ChainType;
 #define btck_ChainType_SIGNET ((btck_ChainType)(3))
 #define btck_ChainType_REGTEST ((btck_ChainType)(4))
 
-/**
- * Function signature for serializing data.
- */
-typedef int (*btck_WriteBytes)(const void* bytes, size_t size, void* userdata);
-
 /** @name Transaction
  * Functions for working with transactions.
  */
@@ -965,6 +965,21 @@ BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_count_trans
 BITCOINKERNEL_API const btck_Transaction* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_get_transaction_at(
     const btck_Block* block, size_t transaction_index) BITCOINKERNEL_ARG_NONNULL(1);
 
+/*
+ * @brief Serializes the block through the passed in callback to bytes.
+ * This is consensus serialization that is also used for the p2p network.
+ *
+ * @param[in] block     Non-null.
+ * @param[in] writer    Non-null, callback to a write bytes function.
+ * @param[in] user_data Holds a user-defined opaque structure that will be
+ *                      passed back through the writer callback.
+ * @return              0 on success.
+ */
+BITCOINKERNEL_API int btck_block_to_bytes(
+    const btck_Block* block,
+    btck_WriteBytes writer,
+    void* user_data) BITCOINKERNEL_ARG_NONNULL(1, 2);
+
 /**
  * Destroy the block.
  */
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index 058bf25d361..82b435dd989 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -551,6 +551,11 @@ public:
         return Range<Block, &Block::CountTransactions, &Block::GetTransaction>{*this};
     }
 
+    std::vector<std::byte> ToBytes() const
+    {
+        return write_bytes(get(), btck_block_to_bytes);
+    }
+
     friend class ChainMan;
 };
 
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index df4fd4104ac..b4997556762 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -16,6 +16,7 @@
 #include <filesystem>
 #include <iostream>
 #include <memory>
+#include <optional>
 #include <random>
 #include <ranges>
 #include <span>
@@ -134,9 +135,16 @@ public:
 class TestValidationInterface : public ValidationInterface<TestValidationInterface>
 {
 public:
+    std::optional<std::vector<std::byte>> m_expected_valid_block = std::nullopt;
+
     void BlockChecked(Block block, const BlockValidationState state) override
     {
-        std::cout << "Block checked: ";
+        {
+            auto ser_block{block.ToBytes()};
+            if (m_expected_valid_block.has_value()) {
+                check_equal(m_expected_valid_block.value(), ser_block);
+            }
+        }
 
         auto mode{state.GetValidationMode()};
         switch (mode) {
@@ -553,8 +561,8 @@ BOOST_AUTO_TEST_CASE(btck_context_tests)
 BOOST_AUTO_TEST_CASE(btck_block)
 {
     Block block{as_bytes(REGTEST_BLOCK_DATA[0])};
-    Block block_1{as_bytes(REGTEST_BLOCK_DATA[1])};
-    CheckHandle(block, block_1);
+    Block block_100{as_bytes(REGTEST_BLOCK_DATA[100])};
+    CheckHandle(block, block_100);
     Block block_tx{as_bytes(REGTEST_BLOCK_DATA[205])};
     CheckRange(block_tx.Transactions(), block_tx.CountTransactions());
 }
@@ -701,10 +709,20 @@ void chainman_mainnet_validation_test(TestDirectory& test_directory)
                                return tx.CountOutputs();
                            })).begin();
     BOOST_CHECK_EQUAL(output_counts, 1);
+
+    validation_interface->m_expected_valid_block.emplace(raw_block);
+    auto ser_block{block.ToBytes()};
+    check_equal(ser_block, raw_block);
     bool new_block = false;
     BOOST_CHECK(chainman->ProcessBlock(block, &new_block));
     BOOST_CHECK(new_block);
 
+    validation_interface->m_expected_valid_block = std::nullopt;
+    new_block = false;
+    Block invalid_block{as_bytes(REGTEST_BLOCK_DATA[REGTEST_BLOCK_DATA.size() - 1])};
+    BOOST_CHECK(!chainman->ProcessBlock(invalid_block, &new_block));
+    BOOST_CHECK(!new_block);
+
     // If we try to validate it again, it should be a duplicate
     BOOST_CHECK(chainman->ProcessBlock(block, &new_block));
     BOOST_CHECK(!new_block);

From 3a2b8d855de8ff664265560177edd6d3cf5580d8 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Sat, 1 Jun 2024 13:03:31 +0200
Subject: [PATCH 17/24] kernel: Add functions to read block from disk to C
 header

This adds functions for reading a block from disk with a retrieved block
tree entry. External services that wish to build their own index, or
analyze blocks can use this to retrieve block data.

The block tree can now be traversed from the tip backwards. This is
guaranteed to work, since the chainstate maintains an internal block
tree index in memory and every block (besides the genesis) has an
ancestor.

The user can use this function to iterate through all blocks in the
chain (starting from the tip). The tip is retrieved from a separate
`Chain` object, which allows distinguishing whether entries are
currently in the best chain. Once the block tree entry for the genesis
block is reached a nullptr is returned if the user attempts to get the
previous entry.
---
 src/kernel/bitcoinkernel.cpp       | 36 ++++++++++++++
 src/kernel/bitcoinkernel.h         | 75 ++++++++++++++++++++++++++++++
 src/kernel/bitcoinkernel_wrapper.h | 38 +++++++++++++++
 src/test/kernel/test_kernel.cpp    | 26 +++++++++++
 4 files changed, 175 insertions(+)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index ee22337d0e7..e75d9e21dc0 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -491,6 +491,7 @@ struct btck_Context : Handle<btck_Context, std::shared_ptr<const Context>> {};
 struct btck_ChainParameters : Handle<btck_ChainParameters, std::unique_ptr<const CChainParams>> {};
 struct btck_ChainstateManagerOptions : Handle<btck_ChainstateManagerOptions, ChainstateManagerOptions> {};
 struct btck_ChainstateManager : Handle<btck_ChainstateManager, ChainMan> {};
+struct btck_Chain : Handle<btck_Chain, CChain> {};
 
 btck_Transaction* btck_transaction_create(const void* raw_transaction, size_t raw_transaction_len)
 {
@@ -763,6 +764,16 @@ void btck_context_destroy(btck_Context* context)
     delete context;
 }
 
+const btck_BlockTreeEntry* btck_block_tree_entry_get_previous(const btck_BlockTreeEntry* entry)
+{
+    if (!btck_BlockTreeEntry::get(entry).pprev) {
+        LogInfo("Genesis block has no previous.");
+        return nullptr;
+    }
+
+    return btck_BlockTreeEntry::ref(btck_BlockTreeEntry::get(entry).pprev);
+}
+
 btck_ValidationMode btck_block_validation_state_get_validation_mode(const btck_BlockValidationState* block_validation_state_)
 {
     auto& block_validation_state = btck_BlockValidationState::get(block_validation_state_);
@@ -978,6 +989,16 @@ void btck_block_destroy(btck_Block* block)
     delete block;
 }
 
+btck_Block* btck_block_read(const btck_ChainstateManager* chainman, const btck_BlockTreeEntry* entry)
+{
+    auto block{std::make_shared<CBlock>()};
+    if (!btck_ChainstateManager::get(chainman).m_chainman->m_blockman.ReadBlock(*block, btck_BlockTreeEntry::get(entry))) {
+        LogError("Failed to read block.");
+        return nullptr;
+    }
+    return btck_Block::create(block);
+}
+
 int btck_chainstate_manager_process_block(
     btck_ChainstateManager* chainman,
     const btck_Block* block,
@@ -990,3 +1011,18 @@ int btck_chainstate_manager_process_block(
     }
     return result ? 0 : -1;
 }
+
+const btck_Chain* btck_chainstate_manager_get_active_chain(const btck_ChainstateManager* chainman)
+{
+    return btck_Chain::ref(&WITH_LOCK(btck_ChainstateManager::get(chainman).m_chainman->GetMutex(), return btck_ChainstateManager::get(chainman).m_chainman->ActiveChain()));
+}
+
+const btck_BlockTreeEntry* btck_chain_get_tip(const btck_Chain* chain)
+{
+    return btck_BlockTreeEntry::ref(btck_Chain::get(chain).Tip());
+}
+
+int btck_chain_get_height(const btck_Chain* chain)
+{
+    return btck_Chain::get(chain).Height();
+}
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index ce87db1649a..b8168cc0e42 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -205,6 +205,12 @@ typedef struct btck_Block btck_Block;
  */
 typedef struct btck_BlockValidationState btck_BlockValidationState;
 
+/**
+ * Opaque data structure for holding the currently known best-chain associated
+ * with a chainstate.
+ */
+typedef struct btck_Chain btck_Chain;
+
 /** Current sync state passed to tip changed callbacks. */
 typedef uint8_t btck_SynchronizationState;
 #define btck_SynchronizationState_INIT_REINDEX ((btck_SynchronizationState)(0))
@@ -785,6 +791,23 @@ BITCOINKERNEL_API void btck_context_destroy(btck_Context* context);
 
 ///@}
 
+/** @name BlockTreeEntry
+ * Functions for working with block tree entries.
+ */
+///@{
+
+/**
+ * @brief Returns the previous block tree entry in the chain, or null if the current
+ * block tree entry is the genesis block.
+ *
+ * @param[in] block_tree_entry Non-null.
+ * @return                     The previous block tree entry, or null on error or if the current block tree entry is the genesis block.
+ */
+BITCOINKERNEL_API const btck_BlockTreeEntry* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_tree_entry_get_previous(
+    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1);
+
+///@}
+
 /** @name ChainstateManagerOptions
  * Functions for working with chainstate manager options.
  */
@@ -913,6 +936,20 @@ BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_p
     const btck_Block* block,
     int* new_block) BITCOINKERNEL_ARG_NONNULL(1, 2, 3);
 
+/**
+ * @brief Returns the best known currently active chain. Its lifetime is
+ * dependent on the chainstate manager and state transitions within the
+ * chainstate manager, e.g. when processing blocks, will also change the chain.
+ * Data retrieved from this chain is only consistent up to the point when new
+ * data is processed in the chainstate manager. It is the user's responsibility
+ * to guard against these inconsistencies.
+ *
+ * @param[in] chainstate_manager Non-null.
+ * @return                       The chain.
+ */
+BITCOINKERNEL_API const btck_Chain* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_get_active_chain(
+    const btck_ChainstateManager* chainstate_manager) BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * Destroy the chainstate manager.
  */
@@ -925,6 +962,18 @@ BITCOINKERNEL_API void btck_chainstate_manager_destroy(btck_ChainstateManager* c
  */
 ///@{
 
+/**
+ * @brief Reads the block the passed in block tree entry points to from disk and
+ * returns it.
+ *
+ * @param[in] chainstate_manager Non-null.
+ * @param[in] block_tree_entry   Non-null.
+ * @return                       The read out block, or null on error.
+ */
+BITCOINKERNEL_API btck_Block* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_read(
+    const btck_ChainstateManager* chainstate_manager,
+    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1, 2);
+
 /**
  * @brief Parse a serialized raw block into a new block object.
  *
@@ -1006,6 +1055,32 @@ BITCOINKERNEL_API btck_BlockValidationResult btck_block_validation_state_get_blo
 
 ///@}
 
+/** @name Chain
+ * Functions for working with the chain
+ */
+///@{
+
+/**
+ * @brief Get the block tree entry of the current chain tip. Once returned,
+ * there is no guarantee that it remains in the active chain.
+ *
+ * @param[in] chain Non-null.
+ * @return          The block tree entry of the current tip, or null if the chain is empty.
+ */
+BITCOINKERNEL_API const btck_BlockTreeEntry* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chain_get_tip(
+    const btck_Chain* chain) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Return the height of the tip of the chain.
+ *
+ * @param[in] chain Non-null.
+ * @return          The current height.
+ */
+BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_chain_get_height(
+    const btck_Chain* chain) BITCOINKERNEL_ARG_NONNULL(1);
+
+///@}
+
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index 82b435dd989..6267cd6e964 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -9,6 +9,7 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <span>
 #include <stdexcept>
 #include <string>
@@ -605,6 +606,15 @@ public:
         : View{entry}
     {
     }
+
+    std::optional<BlockTreeEntry> GetPrevious() const
+    {
+        auto entry{btck_block_tree_entry_get_previous(get())};
+        if (!entry) return std::nullopt;
+        return entry;
+    }
+
+    friend class ChainMan;
 };
 
 template <typename T>
@@ -776,6 +786,22 @@ public:
     friend class ChainMan;
 };
 
+class ChainView : public View<btck_Chain>
+{
+public:
+    explicit ChainView(const btck_Chain* ptr) : View{ptr} {}
+
+    BlockTreeEntry Tip() const
+    {
+        return btck_chain_get_tip(get());
+    }
+
+    int Height() const
+    {
+        return btck_chain_get_height(get());
+    }
+};
+
 class ChainMan : UniqueHandle<btck_ChainstateManager, btck_chainstate_manager_destroy>
 {
 public:
@@ -805,6 +831,18 @@ public:
         if (new_block) *new_block = _new_block == 1;
         return res == 0;
     }
+
+    ChainView GetChain() const
+    {
+        return ChainView{btck_chainstate_manager_get_active_chain(get())};
+    }
+
+    std::optional<Block> ReadBlock(const BlockTreeEntry& entry) const
+    {
+        auto block{btck_block_read(get(), entry.get())};
+        if (!block) return std::nullopt;
+        return block;
+    }
 };
 
 } // namespace btck
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index b4997556762..ecb57a28db9 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -723,6 +723,20 @@ void chainman_mainnet_validation_test(TestDirectory& test_directory)
     BOOST_CHECK(!chainman->ProcessBlock(invalid_block, &new_block));
     BOOST_CHECK(!new_block);
 
+    auto chain{chainman->GetChain()};
+    BOOST_CHECK_EQUAL(chain.Height(), 1);
+    auto tip{chain.Tip()};
+    auto read_block{chainman->ReadBlock(tip)};
+    BOOST_REQUIRE(read_block);
+    check_equal(read_block.value().ToBytes(), raw_block);
+
+    // Check that we can read the previous block
+    auto tip_2{tip.GetPrevious()};
+    auto read_block_2{chainman->ReadBlock(tip_2.value())};
+
+    // It should be an error if we go another block back, since the genesis has no ancestor
+    BOOST_CHECK(!tip_2.value().GetPrevious());
+
     // If we try to validate it again, it should be a duplicate
     BOOST_CHECK(chainman->ProcessBlock(block, &new_block));
     BOOST_CHECK(!new_block);
@@ -796,4 +810,16 @@ BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
         BOOST_CHECK(chainman->ProcessBlock(block, &new_block));
         BOOST_CHECK(new_block);
     }
+
+    auto chain = chainman->GetChain();
+    auto tip = chain.Tip();
+    auto read_block = chainman->ReadBlock(tip).value();
+    check_equal(read_block.ToBytes(), as_bytes(REGTEST_BLOCK_DATA[REGTEST_BLOCK_DATA.size() - 1]));
+
+    auto tip_2 = tip.GetPrevious().value();
+    auto read_block_2 = chainman->ReadBlock(tip_2).value();
+    check_equal(read_block_2.ToBytes(), as_bytes(REGTEST_BLOCK_DATA[REGTEST_BLOCK_DATA.size() - 2]));
+
+    std::filesystem::remove_all(test_directory.m_directory / "blocks" / "blk00000.dat");
+    BOOST_CHECK(!chainman->ReadBlock(tip_2));
 }

From d9d040fd161d64755760a2c5e323642e3d81bbb7 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Sat, 1 Jun 2024 14:47:56 +0200
Subject: [PATCH 18/24] kernel: Add function to read block undo data from disk
 to C header

This adds functions for reading the undo data from disk with a retrieved
block tree entry. The undo data of a block contains all the spent
script pubkeys of all the transactions in a block. For ease of
understanding the undo data is renamed to spent outputs with seperate
data structures exposed for a block's and a transaction's spent outputs.

In normal operations undo data is used during re-orgs. This data might
also be useful for building external indexes, or to scan for silent
payment transactions.

Internally the block undo data contains a vector of transaction undo
data which contains a vector of the coins consumed. The coins are all
int the order of the transaction inputs of the consuming transactions.
Each coin can be used to retrieve a transaction output and in turn a
script pubkey and amount.

This translates to the three-level hierarchy the api provides: Block
spent outputs contain transaction spent outputs, which contain
individual coins. Each coin includes the associated output, the height
of the block is contained in, and whether it is from a coinbase
transaction.
---
 src/kernel/bitcoinkernel.cpp       |  88 ++++++++++++++
 src/kernel/bitcoinkernel.h         | 180 +++++++++++++++++++++++++++++
 src/kernel/bitcoinkernel_wrapper.h | 110 ++++++++++++++++++
 src/test/kernel/test_kernel.cpp    |  43 ++++++-
 4 files changed, 417 insertions(+), 4 deletions(-)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index e75d9e21dc0..d950c6732d3 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -7,6 +7,7 @@
 #include <kernel/bitcoinkernel.h>
 
 #include <chain.h>
+#include <coins.h>
 #include <consensus/amount.h>
 #include <consensus/validation.h>
 #include <kernel/caches.h>
@@ -28,6 +29,7 @@
 #include <sync.h>
 #include <tinyformat.h>
 #include <uint256.h>
+#include <undo.h>
 #include <util/fs.h>
 #include <util/result.h>
 #include <util/signalinterrupt.h>
@@ -492,6 +494,9 @@ struct btck_ChainParameters : Handle<btck_ChainParameters, std::unique_ptr<const
 struct btck_ChainstateManagerOptions : Handle<btck_ChainstateManagerOptions, ChainstateManagerOptions> {};
 struct btck_ChainstateManager : Handle<btck_ChainstateManager, ChainMan> {};
 struct btck_Chain : Handle<btck_Chain, CChain> {};
+struct btck_BlockSpentOutputs : Handle<btck_BlockSpentOutputs, std::shared_ptr<CBlockUndo>> {};
+struct btck_TransactionSpentOutputs : Handle<btck_TransactionSpentOutputs, CTxUndo> {};
+struct btck_Coin : Handle<btck_Coin, Coin> {};
 
 btck_Transaction* btck_transaction_create(const void* raw_transaction, size_t raw_transaction_len)
 {
@@ -999,6 +1004,89 @@ btck_Block* btck_block_read(const btck_ChainstateManager* chainman, const btck_B
     return btck_Block::create(block);
 }
 
+btck_BlockSpentOutputs* btck_block_spent_outputs_read(const btck_ChainstateManager* chainman, const btck_BlockTreeEntry* entry)
+{
+    auto block_undo{std::make_shared<CBlockUndo>()};
+    if (btck_BlockTreeEntry::get(entry).nHeight < 1) {
+        LogDebug(BCLog::KERNEL, "The genesis block does not have any spent outputs.");
+        return btck_BlockSpentOutputs::create(block_undo);
+    }
+    if (!btck_ChainstateManager::get(chainman).m_chainman->m_blockman.ReadBlockUndo(*block_undo, btck_BlockTreeEntry::get(entry))) {
+        LogError("Failed to read block spent outputs data.");
+        return nullptr;
+    }
+    return btck_BlockSpentOutputs::create(block_undo);
+}
+
+btck_BlockSpentOutputs* btck_block_spent_outputs_copy(const btck_BlockSpentOutputs* block_spent_outputs)
+{
+    return btck_BlockSpentOutputs::copy(block_spent_outputs);
+}
+
+size_t btck_block_spent_outputs_count(const btck_BlockSpentOutputs* block_spent_outputs)
+{
+    return btck_BlockSpentOutputs::get(block_spent_outputs)->vtxundo.size();
+}
+
+const btck_TransactionSpentOutputs* btck_block_spent_outputs_get_transaction_spent_outputs_at(const btck_BlockSpentOutputs* block_spent_outputs, size_t transaction_index)
+{
+    assert(transaction_index < btck_BlockSpentOutputs::get(block_spent_outputs)->vtxundo.size());
+    const auto* tx_undo{&btck_BlockSpentOutputs::get(block_spent_outputs)->vtxundo.at(transaction_index)};
+    return btck_TransactionSpentOutputs::ref(tx_undo);
+}
+
+void btck_block_spent_outputs_destroy(btck_BlockSpentOutputs* block_spent_outputs)
+{
+    delete block_spent_outputs;
+}
+
+btck_TransactionSpentOutputs* btck_transaction_spent_outputs_copy(const btck_TransactionSpentOutputs* transaction_spent_outputs)
+{
+    return btck_TransactionSpentOutputs::copy(transaction_spent_outputs);
+}
+
+size_t btck_transaction_spent_outputs_count(const btck_TransactionSpentOutputs* transaction_spent_outputs)
+{
+    return btck_TransactionSpentOutputs::get(transaction_spent_outputs).vprevout.size();
+}
+
+void btck_transaction_spent_outputs_destroy(btck_TransactionSpentOutputs* transaction_spent_outputs)
+{
+    delete transaction_spent_outputs;
+}
+
+const btck_Coin* btck_transaction_spent_outputs_get_coin_at(const btck_TransactionSpentOutputs* transaction_spent_outputs, size_t coin_index)
+{
+    assert(coin_index < btck_TransactionSpentOutputs::get(transaction_spent_outputs).vprevout.size());
+    const Coin* coin{&btck_TransactionSpentOutputs::get(transaction_spent_outputs).vprevout.at(coin_index)};
+    return btck_Coin::ref(coin);
+}
+
+btck_Coin* btck_coin_copy(const btck_Coin* coin)
+{
+    return btck_Coin::copy(coin);
+}
+
+uint32_t btck_coin_confirmation_height(const btck_Coin* coin)
+{
+    return btck_Coin::get(coin).nHeight;
+}
+
+int btck_coin_is_coinbase(const btck_Coin* coin)
+{
+    return btck_Coin::get(coin).IsCoinBase() ? 1 : 0;
+}
+
+const btck_TransactionOutput* btck_coin_get_output(const btck_Coin* coin)
+{
+    return btck_TransactionOutput::ref(&btck_Coin::get(coin).out);
+}
+
+void btck_coin_destroy(btck_Coin* coin)
+{
+    delete coin;
+}
+
 int btck_chainstate_manager_process_block(
     btck_ChainstateManager* chainman,
     const btck_Block* block,
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index b8168cc0e42..5f02884c96b 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -211,6 +211,36 @@ typedef struct btck_BlockValidationState btck_BlockValidationState;
  */
 typedef struct btck_Chain btck_Chain;
 
+/**
+ * Opaque data structure for holding a block's spent outputs.
+ *
+ * Contains all the previous outputs consumed by all transactions in a specific
+ * block. Internally it holds a nested vector. The top level vector has an
+ * entry for each transaction in a block (in order of the actual transactions
+ * of the block and without the coinbase transaction). This is exposed through
+ * @ref btck_TransactionSpentOutputs. Each btck_TransactionSpentOutputs is in
+ * turn a vector of all the previous outputs of a transaction (in order of
+ * their corresponding inputs).
+ */
+typedef struct btck_BlockSpentOutputs btck_BlockSpentOutputs;
+
+/**
+ * Opaque data structure for holding a transaction's spent outputs.
+ *
+ * Holds the coins consumed by a certain transaction. Retrieved through the
+ * @ref btck_BlockSpentOutputs. The coins are in the same order as the
+ * transaction's inputs consuming them.
+ */
+typedef struct btck_TransactionSpentOutputs btck_TransactionSpentOutputs;
+
+/**
+ * Opaque data structure for holding a coin.
+ *
+ * Holds information on the @ref btck_TransactionOutput held within,
+ * including the height it was spent at and whether it is a coinbase output.
+ */
+typedef struct btck_Coin btck_Coin;
+
 /** Current sync state passed to tip changed callbacks. */
 typedef uint8_t btck_SynchronizationState;
 #define btck_SynchronizationState_INIT_REINDEX ((btck_SynchronizationState)(0))
@@ -1081,6 +1111,156 @@ BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_chain_get_height(
 
 ///@}
 
+/** @name BlockSpentOutputs
+ * Functions for working with block spent outputs.
+ */
+///@{
+
+/**
+ * @brief Reads the block spent coins data the passed in block tree entry points to from
+ * disk and returns it.
+ *
+ * @param[in] chainstate_manager Non-null.
+ * @param[in] block_tree_entry   Non-null.
+ * @return                       The read out block spent outputs, or null on error.
+ */
+BITCOINKERNEL_API btck_BlockSpentOutputs* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_spent_outputs_read(
+    const btck_ChainstateManager* chainstate_manager,
+    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1, 2);
+
+/**
+ * @brief Copy a block's spent outputs.
+ *
+ * @param[in] block_spent_outputs Non-null.
+ * @return                        The copied block spent outputs.
+ */
+BITCOINKERNEL_API btck_BlockSpentOutputs* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_spent_outputs_copy(
+    const btck_BlockSpentOutputs* block_spent_outputs) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Returns the number of transaction spent outputs whose data is contained in
+ * block spent outputs.
+ *
+ * @param[in] block_spent_outputs Non-null.
+ * @return                        The number of transaction spent outputs data in the block spent outputs.
+ */
+BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_spent_outputs_count(
+    const btck_BlockSpentOutputs* block_spent_outputs) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Returns a transaction spent outputs contained in the block spent
+ * outputs at a certain index. The returned pointer is unowned and only valid
+ * for the lifetime of block_spent_outputs.
+ *
+ * @param[in] block_spent_outputs             Non-null.
+ * @param[in] transaction_spent_outputs_index The index of the transaction spent outputs within the block spent outputs.
+ * @return                                    A transaction spent outputs pointer.
+ */
+BITCOINKERNEL_API const btck_TransactionSpentOutputs* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_spent_outputs_get_transaction_spent_outputs_at(
+    const btck_BlockSpentOutputs* block_spent_outputs,
+    size_t transaction_spent_outputs_index) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Destroy the block spent outputs.
+ */
+BITCOINKERNEL_API void btck_block_spent_outputs_destroy(btck_BlockSpentOutputs* block_spent_outputs);
+
+///@}
+
+/** @name TransactionSpentOutputs
+ * Functions for working with the spent coins of a transaction
+ */
+///@{
+
+/**
+ * @brief Copy a transaction's spent outputs.
+ *
+ * @param[in] transaction_spent_outputs Non-null.
+ * @return                              The copied transaction spent outputs.
+ */
+BITCOINKERNEL_API btck_TransactionSpentOutputs* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_spent_outputs_copy(
+    const btck_TransactionSpentOutputs* transaction_spent_outputs) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Returns the number of previous transaction outputs contained in the
+ * transaction spent outputs data.
+ *
+ * @param[in] transaction_spent_outputs Non-null
+ * @return                              The number of spent transaction outputs for the transaction.
+ */
+BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_spent_outputs_count(
+    const btck_TransactionSpentOutputs* transaction_spent_outputs) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Returns a coin contained in the transaction spent outputs at a
+ * certain index. The returned pointer is unowned and only valid for the
+ * lifetime of transaction_spent_outputs.
+ *
+ * @param[in] transaction_spent_outputs Non-null.
+ * @param[in] coin_index                The index of the to be retrieved coin within the
+ *                                      transaction spent outputs.
+ * @return                              A coin pointer.
+ */
+BITCOINKERNEL_API const btck_Coin* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_spent_outputs_get_coin_at(
+    const btck_TransactionSpentOutputs* transaction_spent_outputs,
+    size_t coin_index) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Destroy the transaction spent outputs.
+ */
+BITCOINKERNEL_API void btck_transaction_spent_outputs_destroy(btck_TransactionSpentOutputs* transaction_spent_outputs);
+
+///@}
+
+/** @name Coin
+ * Functions for working with coins.
+ */
+///@{
+
+/**
+ * @brief Copy a coin.
+ *
+ * @param[in] coin Non-null.
+ * @return         The copied coin.
+ */
+BITCOINKERNEL_API btck_Coin* BITCOINKERNEL_WARN_UNUSED_RESULT btck_coin_copy(
+    const btck_Coin* coin) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Returns the height of the block that contains the coin's prevout.
+ *
+ * @param[in] coin Non-null.
+ * @return         The block height of the coin.
+ */
+BITCOINKERNEL_API uint32_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_coin_confirmation_height(
+    const btck_Coin* coin) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Returns whether the containing transaction was a coinbase.
+ *
+ * @param[in] coin Non-null.
+ * @return         1 if the coin is a coinbase coin, 0 otherwise.
+ */
+BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_coin_is_coinbase(
+    const btck_Coin* coin) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Return the transaction output of a coin. The returned pointer is
+ * unowned and only valid for the lifetime of the coin.
+ *
+ * @param[in] coin Non-null.
+ * @return         A transaction output pointer.
+ */
+BITCOINKERNEL_API const btck_TransactionOutput* BITCOINKERNEL_WARN_UNUSED_RESULT btck_coin_get_output(
+    const btck_Coin* coin) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Destroy the coin.
+ */
+BITCOINKERNEL_API void btck_coin_destroy(btck_Coin* coin);
+
+///@}
+
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index 6267cd6e964..059e02b795a 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -802,6 +802,111 @@ public:
     }
 };
 
+template <typename Derived>
+class CoinApi
+{
+private:
+    auto impl() const
+    {
+        return static_cast<const Derived*>(this)->get();
+    }
+
+    friend Derived;
+    CoinApi() = default;
+
+public:
+    uint32_t GetConfirmationHeight() const { return btck_coin_confirmation_height(impl()); }
+
+    bool IsCoinbase() const { return btck_coin_is_coinbase(impl()) == 1; }
+
+    TransactionOutputView GetOutput() const
+    {
+        return TransactionOutputView{btck_coin_get_output(impl())};
+    }
+};
+
+class CoinView : public View<btck_Coin>, public CoinApi<CoinView>
+{
+public:
+    explicit CoinView(const btck_Coin* ptr) : View{ptr} {}
+};
+
+class Coin : public Handle<btck_Coin, btck_coin_copy, btck_coin_destroy>, public CoinApi<Coin>
+{
+public:
+    Coin(btck_Coin* coin) : Handle{coin} {}
+
+    Coin(const CoinView& view) : Handle{view} {}
+};
+
+template <typename Derived>
+class TransactionSpentOutputsApi
+{
+private:
+    auto impl() const
+    {
+        return static_cast<const Derived*>(this)->get();
+    }
+
+    friend Derived;
+    TransactionSpentOutputsApi() = default;
+
+public:
+    size_t Count() const
+    {
+        return btck_transaction_spent_outputs_count(impl());
+    }
+
+    CoinView GetCoin(size_t index) const
+    {
+        return CoinView{btck_transaction_spent_outputs_get_coin_at(impl(), index)};
+    }
+
+    auto Coins() const
+    {
+        return Range<Derived, &TransactionSpentOutputsApi<Derived>::Count, &TransactionSpentOutputsApi<Derived>::GetCoin>{*static_cast<const Derived*>(this)};
+    }
+};
+
+class TransactionSpentOutputsView : public View<btck_TransactionSpentOutputs>, public TransactionSpentOutputsApi<TransactionSpentOutputsView>
+{
+public:
+    explicit TransactionSpentOutputsView(const btck_TransactionSpentOutputs* ptr) : View{ptr} {}
+};
+
+class TransactionSpentOutputs : public Handle<btck_TransactionSpentOutputs, btck_transaction_spent_outputs_copy, btck_transaction_spent_outputs_destroy>,
+                                public TransactionSpentOutputsApi<TransactionSpentOutputs>
+{
+public:
+    TransactionSpentOutputs(btck_TransactionSpentOutputs* transaction_spent_outputs) : Handle{transaction_spent_outputs} {}
+
+    TransactionSpentOutputs(const TransactionSpentOutputsView& view) : Handle{view} {}
+};
+
+class BlockSpentOutputs : public Handle<btck_BlockSpentOutputs, btck_block_spent_outputs_copy, btck_block_spent_outputs_destroy>
+{
+public:
+    BlockSpentOutputs(btck_BlockSpentOutputs* block_spent_outputs)
+        : Handle{block_spent_outputs}
+    {
+    }
+
+    size_t Count() const
+    {
+        return btck_block_spent_outputs_count(get());
+    }
+
+    TransactionSpentOutputsView GetTxSpentOutputs(size_t tx_undo_index) const
+    {
+        return TransactionSpentOutputsView{btck_block_spent_outputs_get_transaction_spent_outputs_at(get(), tx_undo_index)};
+    }
+
+    auto TxsSpentOutputs() const
+    {
+        return Range<BlockSpentOutputs, &BlockSpentOutputs::Count, &BlockSpentOutputs::GetTxSpentOutputs>{*this};
+    }
+};
+
 class ChainMan : UniqueHandle<btck_ChainstateManager, btck_chainstate_manager_destroy>
 {
 public:
@@ -843,6 +948,11 @@ public:
         if (!block) return std::nullopt;
         return block;
     }
+
+    BlockSpentOutputs ReadBlockSpentOutputs(const BlockTreeEntry& entry) const
+    {
+        return btck_block_spent_outputs_read(get(), entry.get());
+    }
 };
 
 } // namespace btck
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index ecb57a28db9..a8def15531f 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -731,11 +731,13 @@ void chainman_mainnet_validation_test(TestDirectory& test_directory)
     check_equal(read_block.value().ToBytes(), raw_block);
 
     // Check that we can read the previous block
-    auto tip_2{tip.GetPrevious()};
-    auto read_block_2{chainman->ReadBlock(tip_2.value())};
+    BlockTreeEntry tip_2{*tip.GetPrevious()};
+    Block read_block_2{*chainman->ReadBlock(tip_2)};
+    BOOST_CHECK_EQUAL(chainman->ReadBlockSpentOutputs(tip_2).Count(), 0);
+    BOOST_CHECK_EQUAL(chainman->ReadBlockSpentOutputs(tip).Count(), 0);
 
     // It should be an error if we go another block back, since the genesis has no ancestor
-    BOOST_CHECK(!tip_2.value().GetPrevious());
+    BOOST_CHECK(!tip_2.GetPrevious());
 
     // If we try to validate it again, it should be a duplicate
     BOOST_CHECK(chainman->ProcessBlock(block, &new_block));
@@ -820,6 +822,39 @@ BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
     auto read_block_2 = chainman->ReadBlock(tip_2).value();
     check_equal(read_block_2.ToBytes(), as_bytes(REGTEST_BLOCK_DATA[REGTEST_BLOCK_DATA.size() - 2]));
 
+    BlockSpentOutputs block_spent_outputs{chainman->ReadBlockSpentOutputs(tip)};
+    BlockSpentOutputs block_spent_outputs_prev{chainman->ReadBlockSpentOutputs(*tip.GetPrevious())};
+    CheckHandle(block_spent_outputs, block_spent_outputs_prev);
+    CheckRange(block_spent_outputs_prev.TxsSpentOutputs(), block_spent_outputs_prev.Count());
+    BOOST_CHECK_EQUAL(block_spent_outputs.Count(), 1);
+    TransactionSpentOutputsView transaction_spent_outputs{block_spent_outputs.GetTxSpentOutputs(block_spent_outputs.Count() - 1)};
+    TransactionSpentOutputs owned_transaction_spent_outputs{transaction_spent_outputs};
+    TransactionSpentOutputs owned_transaction_spent_outputs_prev{block_spent_outputs_prev.GetTxSpentOutputs(block_spent_outputs_prev.Count() - 1)};
+    CheckHandle(owned_transaction_spent_outputs, owned_transaction_spent_outputs_prev);
+    CheckRange(transaction_spent_outputs.Coins(), transaction_spent_outputs.Count());
+    CoinView coin{transaction_spent_outputs.GetCoin(transaction_spent_outputs.Count() - 1)};
+    BOOST_CHECK(!coin.IsCoinbase());
+    Coin owned_coin{coin};
+    Coin owned_coin_prev{owned_transaction_spent_outputs_prev.GetCoin(owned_transaction_spent_outputs_prev.Count() - 1)};
+    CheckHandle(owned_coin, owned_coin_prev);
+    TransactionOutputView output = coin.GetOutput();
+    uint32_t coin_height = coin.GetConfirmationHeight();
+    BOOST_CHECK_EQUAL(coin_height, 205);
+    BOOST_CHECK_EQUAL(output.Amount(), 100000000);
+    auto script_pubkey = output.GetScriptPubkey();
+    auto script_pubkey_bytes{script_pubkey.ToBytes()};
+    BOOST_CHECK_EQUAL(script_pubkey_bytes.size(), 22);
+    auto round_trip_script_pubkey{ScriptPubkey(script_pubkey_bytes)};
+    BOOST_CHECK_EQUAL(round_trip_script_pubkey.ToBytes().size(), 22);
+
+    for (const auto tx_spent_outputs : block_spent_outputs.TxsSpentOutputs()) {
+        for (const auto coins : tx_spent_outputs.Coins()) {
+            BOOST_CHECK_GT(coins.GetOutput().Amount(), 1);
+        }
+    }
+
     std::filesystem::remove_all(test_directory.m_directory / "blocks" / "blk00000.dat");
-    BOOST_CHECK(!chainman->ReadBlock(tip_2));
+    BOOST_CHECK(!chainman->ReadBlock(tip_2).has_value());
+    std::filesystem::remove_all(test_directory.m_directory / "blocks" / "rev00000.dat");
+    BOOST_CHECK_THROW(chainman->ReadBlockSpentOutputs(tip), std::runtime_error);
 }

From 00000cb55a3ba7815006b59b4a1d259feb83ecee Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Wed, 5 Jun 2024 22:05:40 +0200
Subject: [PATCH 19/24] kernel: Add block hash type and block tree utility
 functions to C header

Introduce btck_BlockHash as a type-safe identifier for a block. Adds
functions to retrieve block tree entries by hash or height, get block
hashes and heights from entries. access the genesis block, and check if
blocks are in the active chain.
---
 src/kernel/bitcoinkernel.cpp       |  72 +++++++++++++++++
 src/kernel/bitcoinkernel.h         | 126 +++++++++++++++++++++++++++++
 src/kernel/bitcoinkernel_wrapper.h |  73 ++++++++++++++++-
 src/test/kernel/test_kernel.cpp    |  72 +++++++++++++++++
 4 files changed, 342 insertions(+), 1 deletion(-)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index d950c6732d3..77e46eb03f4 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -497,6 +497,7 @@ struct btck_Chain : Handle<btck_Chain, CChain> {};
 struct btck_BlockSpentOutputs : Handle<btck_BlockSpentOutputs, std::shared_ptr<CBlockUndo>> {};
 struct btck_TransactionSpentOutputs : Handle<btck_TransactionSpentOutputs, CTxUndo> {};
 struct btck_Coin : Handle<btck_Coin, Coin> {};
+struct btck_BlockHash : Handle<btck_BlockHash, uint256> {};
 
 btck_Transaction* btck_transaction_create(const void* raw_transaction, size_t raw_transaction_len)
 {
@@ -912,6 +913,17 @@ btck_ChainstateManager* btck_chainstate_manager_create(
     return btck_ChainstateManager::create(std::move(chainman), opts.m_context);
 }
 
+const btck_BlockTreeEntry* btck_chainstate_manager_get_block_tree_entry_by_hash(const btck_ChainstateManager* chainman, const btck_BlockHash* block_hash)
+{
+    auto block_index = WITH_LOCK(btck_ChainstateManager::get(chainman).m_chainman->GetMutex(),
+                                 return btck_ChainstateManager::get(chainman).m_chainman->m_blockman.LookupBlockIndex(btck_BlockHash::get(block_hash)));
+    if (!block_index) {
+        LogDebug(BCLog::KERNEL, "A block with the given hash is not indexed.");
+        return nullptr;
+    }
+    return btck_BlockTreeEntry::ref(block_index);
+}
+
 void btck_chainstate_manager_destroy(btck_ChainstateManager* chainman)
 {
     {
@@ -989,6 +1001,11 @@ int btck_block_to_bytes(const btck_Block* block, btck_WriteBytes writer, void* u
     }
 }
 
+btck_BlockHash* btck_block_get_hash(const btck_Block* block)
+{
+    return btck_BlockHash::create(btck_Block::get(block)->GetHash());
+}
+
 void btck_block_destroy(btck_Block* block)
 {
     delete block;
@@ -1004,6 +1021,44 @@ btck_Block* btck_block_read(const btck_ChainstateManager* chainman, const btck_B
     return btck_Block::create(block);
 }
 
+int32_t btck_block_tree_entry_get_height(const btck_BlockTreeEntry* entry)
+{
+    return btck_BlockTreeEntry::get(entry).nHeight;
+}
+
+btck_BlockHash* btck_block_tree_entry_get_block_hash(const btck_BlockTreeEntry* entry)
+{
+    if (btck_BlockTreeEntry::get(entry).phashBlock == nullptr) {
+        return nullptr;
+    }
+    return btck_BlockHash::create(btck_BlockTreeEntry::get(entry).GetBlockHash());
+}
+
+btck_BlockHash* btck_block_hash_create(const unsigned char block_hash[32])
+{
+    return btck_BlockHash::create(std::span<const unsigned char>{block_hash, 32});
+}
+
+btck_BlockHash* btck_block_hash_copy(const btck_BlockHash* block_hash)
+{
+    return btck_BlockHash::copy(block_hash);
+}
+
+void btck_block_hash_to_bytes(const btck_BlockHash* block_hash, unsigned char output[32])
+{
+    std::memcpy(output, btck_BlockHash::get(block_hash).begin(), 32);
+}
+
+int btck_block_hash_equals(const btck_BlockHash* hash1, const btck_BlockHash* hash2)
+{
+    return btck_BlockHash::get(hash1) == btck_BlockHash::get(hash2);
+}
+
+void btck_block_hash_destroy(btck_BlockHash* hash)
+{
+    delete hash;
+}
+
 btck_BlockSpentOutputs* btck_block_spent_outputs_read(const btck_ChainstateManager* chainman, const btck_BlockTreeEntry* entry)
 {
     auto block_undo{std::make_shared<CBlockUndo>()};
@@ -1114,3 +1169,20 @@ int btck_chain_get_height(const btck_Chain* chain)
 {
     return btck_Chain::get(chain).Height();
 }
+
+const btck_BlockTreeEntry* btck_chain_get_genesis(const btck_Chain* chain)
+{
+    return btck_BlockTreeEntry::ref(btck_Chain::get(chain).Genesis());
+}
+
+const btck_BlockTreeEntry* btck_chain_get_by_height(const btck_Chain* chain, int height)
+{
+    LOCK(::cs_main);
+    return btck_BlockTreeEntry::ref(btck_Chain::get(chain)[height]);
+}
+
+int btck_chain_contains(const btck_Chain* chain, const btck_BlockTreeEntry* entry)
+{
+    LOCK(::cs_main);
+    return btck_Chain::get(chain).Contains(&btck_BlockTreeEntry::get(entry)) ? 1 : 0;
+}
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index 5f02884c96b..6a8196f8725 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -241,6 +241,13 @@ typedef struct btck_TransactionSpentOutputs btck_TransactionSpentOutputs;
  */
 typedef struct btck_Coin btck_Coin;
 
+/**
+ * Opaque data structure for holding a block hash.
+ *
+ * This is a type-safe identifier for a block.
+ */
+typedef struct btck_BlockHash btck_BlockHash;
+
 /** Current sync state passed to tip changed callbacks. */
 typedef uint8_t btck_SynchronizationState;
 #define btck_SynchronizationState_INIT_REINDEX ((btck_SynchronizationState)(0))
@@ -836,6 +843,24 @@ BITCOINKERNEL_API void btck_context_destroy(btck_Context* context);
 BITCOINKERNEL_API const btck_BlockTreeEntry* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_tree_entry_get_previous(
     const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Return the height of a certain block tree entry.
+ *
+ * @param[in] block_tree_entry Non-null.
+ * @return                     The block height.
+ */
+BITCOINKERNEL_API int32_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_tree_entry_get_height(
+    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Return the block hash associated with a block tree entry.
+ *
+ * @param[in] block_tree_entry Non-null.
+ * @return                     The block hash.
+ */
+BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_tree_entry_get_block_hash(
+    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1);
+
 ///@}
 
 /** @name ChainstateManagerOptions
@@ -980,6 +1005,18 @@ BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_p
 BITCOINKERNEL_API const btck_Chain* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_get_active_chain(
     const btck_ChainstateManager* chainstate_manager) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Retrieve a block tree entry by its block hash.
+ *
+ * @param[in] chainstate_manager Non-null.
+ * @param[in] block_hash         Non-null.
+ * @return                       The block tree entry of the block with the passed in hash, or null if
+ *                               the block hash is not found.
+ */
+BITCOINKERNEL_API const btck_BlockTreeEntry* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_get_block_tree_entry_by_hash(
+    const btck_ChainstateManager* chainstate_manager,
+    const btck_BlockHash* block_hash) BITCOINKERNEL_ARG_NONNULL(1, 2);
+
 /**
  * Destroy the chainstate manager.
  */
@@ -1044,6 +1081,15 @@ BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_count_trans
 BITCOINKERNEL_API const btck_Transaction* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_get_transaction_at(
     const btck_Block* block, size_t transaction_index) BITCOINKERNEL_ARG_NONNULL(1);
 
+/*
+ * @brief Calculate and return the hash of a block.
+ *
+ * @param[in] block Non-null.
+ * @return    The block hash.
+ */
+BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_get_hash(
+    const btck_Block* block) BITCOINKERNEL_ARG_NONNULL(1);
+
 /*
  * @brief Serializes the block through the passed in callback to bytes.
  * This is consensus serialization that is also used for the p2p network.
@@ -1109,6 +1155,40 @@ BITCOINKERNEL_API const btck_BlockTreeEntry* BITCOINKERNEL_WARN_UNUSED_RESULT bt
 BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_chain_get_height(
     const btck_Chain* chain) BITCOINKERNEL_ARG_NONNULL(1);
 
+/*
+ * @brief Get the block tree entry of the genesis block.
+ *
+ * @param[in] chain Non-null.
+ * @return          The block tree entry of the genesis block, or null if the chain is empty.
+ */
+BITCOINKERNEL_API const btck_BlockTreeEntry* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chain_get_genesis(
+    const btck_Chain* chain) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Retrieve a block tree entry by its height in the currently active chain.
+ * Once retrieved there is no guarantee that it remains in the active chain.
+ *
+ * @param[in] chain        Non-null.
+ * @param[in] block_height Height in the chain of the to be retrieved block tree entry.
+ * @return                 The block tree entry at a certain height in the currently active chain, or null
+ *                         if the height is out of bounds.
+ */
+BITCOINKERNEL_API const btck_BlockTreeEntry* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chain_get_by_height(
+    const btck_Chain* chain,
+    int block_height) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Return true if the passed in chain contains the block tree entry.
+ *
+ * @param[in] chain            Non-null.
+ * @param[in] block_tree_entry Non-null.
+ * @return                     1 if the block_tree_entry is in the chain, 0 otherwise.
+ *
+ */
+BITCOINKERNEL_API int btck_chain_contains(
+    const btck_Chain* chain,
+    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1, 2);
+
 ///@}
 
 /** @name BlockSpentOutputs
@@ -1261,6 +1341,52 @@ BITCOINKERNEL_API void btck_coin_destroy(btck_Coin* coin);
 
 ///@}
 
+/** @name BlockHash
+ * Functions for working with block hashes.
+ */
+///@{
+
+/**
+ * @brief Create a block hash from its raw data.
+ */
+BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_hash_create(
+    const unsigned char block_hash[32]) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Check if two block hashes are equal.
+ *
+ * @param[in] hash1 Non-null.
+ * @param[in] hash2 Non-null.
+ * @return          0 if the block hashes are not equal.
+ */
+BITCOINKERNEL_API int btck_block_hash_equals(
+    const btck_BlockHash* hash1, const btck_BlockHash* hash2) BITCOINKERNEL_ARG_NONNULL(1, 2);
+
+/**
+ * @brief Copy a block hash.
+ *
+ * @param[in] block_hash Non-null.
+ * @return               The copied block hash.
+ */
+BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_hash_copy(
+    const btck_BlockHash* block_hash) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Serializes the block hash to bytes.
+ *
+ * @param[in] block_hash     Non-null.
+ * @param[in] output         The serialized block hash.
+ */
+BITCOINKERNEL_API void btck_block_hash_to_bytes(
+    const btck_BlockHash* block_hash, unsigned char output[32]) BITCOINKERNEL_ARG_NONNULL(1, 2);
+
+/**
+ * Destroy the block hash.
+ */
+BITCOINKERNEL_API void btck_block_hash_destroy(btck_BlockHash* block_hash);
+
+///@}
+
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index 059e02b795a..749bed2e95c 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -7,6 +7,7 @@
 
 #include <kernel/bitcoinkernel.h>
 
+#include <array>
 #include <functional>
 #include <memory>
 #include <optional>
@@ -527,6 +528,33 @@ bool ScriptPubkeyApi<Derived>::Verify(int64_t amount,
     return result == 1;
 }
 
+class BlockHash : public Handle<btck_BlockHash, btck_block_hash_copy, btck_block_hash_destroy>
+{
+public:
+    explicit BlockHash(const std::array<std::byte, 32>& hash)
+        : Handle{btck_block_hash_create(reinterpret_cast<const unsigned char*>(hash.data()))} {}
+
+    explicit BlockHash(btck_BlockHash* hash)
+        : Handle{hash} {}
+
+    bool operator==(const BlockHash& other) const
+    {
+        return btck_block_hash_equals(get(), other.get()) != 0;
+    }
+
+    bool operator!=(const BlockHash& other) const
+    {
+        return btck_block_hash_equals(get(), other.get()) == 0;
+    }
+
+    std::array<std::byte, 32> ToBytes() const
+    {
+        std::array<std::byte, 32> hash;
+        btck_block_hash_to_bytes(get(), reinterpret_cast<unsigned char*>(hash.data()));
+        return hash;
+    }
+};
+
 class Block : public Handle<btck_Block, btck_block_copy, btck_block_destroy>
 {
 public:
@@ -552,6 +580,11 @@ public:
         return Range<Block, &Block::CountTransactions, &Block::GetTransaction>{*this};
     }
 
+    BlockHash GetHash() const
+    {
+        return BlockHash{btck_block_get_hash(get())};
+    }
+
     std::vector<std::byte> ToBytes() const
     {
         return write_bytes(get(), btck_block_to_bytes);
@@ -599,7 +632,7 @@ public:
     }
 };
 
-class BlockTreeEntry : View<btck_BlockTreeEntry>
+class BlockTreeEntry : public View<btck_BlockTreeEntry>
 {
 public:
     BlockTreeEntry(const btck_BlockTreeEntry* entry)
@@ -614,7 +647,18 @@ public:
         return entry;
     }
 
+    int32_t GetHeight() const
+    {
+        return btck_block_tree_entry_get_height(get());
+    }
+
+    BlockHash GetHash() const
+    {
+        return BlockHash{btck_block_tree_entry_get_block_hash(get())};
+    }
+
     friend class ChainMan;
+    friend class Chain;
 };
 
 template <typename T>
@@ -800,6 +844,28 @@ public:
     {
         return btck_chain_get_height(get());
     }
+
+    BlockTreeEntry Genesis() const
+    {
+        return btck_chain_get_genesis(get());
+    }
+
+    BlockTreeEntry GetByHeight(int height) const
+    {
+        auto index{btck_chain_get_by_height(get(), height)};
+        if (!index) throw std::runtime_error("No entry in the chain at the provided height");
+        return index;
+    }
+
+    bool Contains(BlockTreeEntry& entry) const
+    {
+        return btck_chain_contains(get(), entry.get());
+    }
+
+    auto Entries() const
+    {
+        return Range<ChainView, &ChainView::Height, &ChainView::GetByHeight>{*this};
+    }
 };
 
 template <typename Derived>
@@ -942,6 +1008,11 @@ public:
         return ChainView{btck_chainstate_manager_get_active_chain(get())};
     }
 
+    BlockTreeEntry GetBlockTreeEntry(const BlockHash& block_hash) const
+    {
+        return btck_chainstate_manager_get_block_tree_entry_by_hash(get(), block_hash.get());
+    }
+
     std::optional<Block> ReadBlock(const BlockTreeEntry& entry) const
     {
         auto block{btck_block_read(get(), entry.get())};
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index a8def15531f..07b5e5b759a 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -664,6 +664,38 @@ void chainman_reindex_test(TestDirectory& test_directory)
 
     std::vector<std::string> import_files;
     BOOST_CHECK(chainman->ImportBlocks(import_files));
+
+    // Sanity check some block retrievals
+    auto chain{chainman->GetChain()};
+    BOOST_CHECK_THROW(chain.GetByHeight(1000), std::runtime_error);
+    auto genesis_index{chain.Genesis()};
+    BOOST_CHECK(!genesis_index.GetPrevious());
+    auto genesis_block_raw{chainman->ReadBlock(genesis_index).value().ToBytes()};
+    auto first_index{chain.GetByHeight(0)};
+    auto first_block_raw{chainman->ReadBlock(genesis_index).value().ToBytes()};
+    check_equal(genesis_block_raw, first_block_raw);
+    auto height{first_index.GetHeight()};
+    BOOST_CHECK_EQUAL(height, 0);
+
+    auto next_index{chain.GetByHeight(first_index.GetHeight() + 1)};
+    BOOST_CHECK(chain.Contains(next_index));
+    auto next_block_data{chainman->ReadBlock(next_index).value().ToBytes()};
+    auto tip_index{chain.Tip()};
+    auto tip_block_data{chainman->ReadBlock(tip_index).value().ToBytes()};
+    auto second_index{chain.GetByHeight(1)};
+    auto second_block{chainman->ReadBlock(second_index).value()};
+    auto second_block_data{second_block.ToBytes()};
+    auto second_height{second_index.GetHeight()};
+    BOOST_CHECK_EQUAL(second_height, 1);
+    check_equal(next_block_data, tip_block_data);
+    check_equal(next_block_data, second_block_data);
+
+    auto second_hash{second_index.GetHash()};
+    auto another_second_index{chainman->GetBlockTreeEntry(second_hash)};
+    auto another_second_height{another_second_index.GetHeight()};
+    auto second_block_hash{second_block.GetHash()};
+    check_equal(second_block_hash.ToBytes(), second_hash.ToBytes());
+    BOOST_CHECK_EQUAL(second_height, another_second_height);
 }
 
 void chainman_reindex_chainstate_test(TestDirectory& test_directory)
@@ -761,6 +793,21 @@ BOOST_AUTO_TEST_CASE(btck_chainman_mainnet_tests)
     chainman_reindex_chainstate_test(test_directory);
 }
 
+BOOST_AUTO_TEST_CASE(btck_block_hash_tests)
+{
+    std::array<std::byte, 32> test_hash;
+    std::array<std::byte, 32> test_hash_2;
+    for (int i = 0; i < 32; ++i) {
+        test_hash[i] = static_cast<std::byte>(i);
+        test_hash_2[i] = static_cast<std::byte>(i + 1);
+    }
+    BlockHash block_hash{test_hash};
+    BlockHash block_hash_2{test_hash_2};
+    BOOST_CHECK(block_hash != block_hash_2);
+    BOOST_CHECK(block_hash == block_hash);
+    CheckHandle(block_hash, block_hash_2);
+}
+
 BOOST_AUTO_TEST_CASE(btck_chainman_in_memory_tests)
 {
     auto in_memory_test_directory{TestDirectory{"in-memory_test_bitcoin_kernel"}};
@@ -853,6 +900,31 @@ BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
         }
     }
 
+    CheckRange(chain.Entries(), chain.Height());
+
+    for (const BlockTreeEntry entry : chain.Entries()) {
+        std::optional<Block> block{chainman->ReadBlock(entry)};
+        if (block) {
+            for (const TransactionView transaction : block->Transactions()) {
+                for (const TransactionOutputView output : transaction.Outputs()) {
+                    // skip data carrier outputs
+                    if ((unsigned char)output.GetScriptPubkey().ToBytes()[0] == 0x6a) {
+                        continue;
+                    }
+                    BOOST_CHECK_GT(output.Amount(), 1);
+                }
+            }
+        }
+    }
+
+    int32_t count{0};
+    for (const auto entry : chain.Entries()) {
+        BOOST_CHECK_EQUAL(entry.GetHeight(), count);
+        ++count;
+    }
+    BOOST_CHECK_EQUAL(count, chain.Height());
+
+
     std::filesystem::remove_all(test_directory.m_directory / "blocks" / "blk00000.dat");
     BOOST_CHECK(!chainman->ReadBlock(tip_2).has_value());
     std::filesystem::remove_all(test_directory.m_directory / "blocks" / "rev00000.dat");

From 7918a4d17d59eef5695f9cb8542bde3e3f6d24c9 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Fri, 19 Sep 2025 22:14:54 +0200
Subject: [PATCH 20/24] Kernel: Add functions for working with outpoints

This introduces the transaction outpoint, input and id types. This now
allows a user to retrieve a transaction output from a prior transaction
that a transaction outpoint is pointing to.

This is exercised in the tests by verifying the script of every
transaction in the test chain.
---
 src/kernel/bitcoinkernel.cpp       |  69 +++++++++++++
 src/kernel/bitcoinkernel.h         | 149 +++++++++++++++++++++++++++++
 src/kernel/bitcoinkernel_wrapper.h | 128 +++++++++++++++++++++++++
 src/test/kernel/test_kernel.cpp    |  69 +++++++++++++
 4 files changed, 415 insertions(+)

diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
index 77e46eb03f4..32e81708888 100644
--- a/src/kernel/bitcoinkernel.cpp
+++ b/src/kernel/bitcoinkernel.cpp
@@ -498,6 +498,9 @@ struct btck_BlockSpentOutputs : Handle<btck_BlockSpentOutputs, std::shared_ptr<C
 struct btck_TransactionSpentOutputs : Handle<btck_TransactionSpentOutputs, CTxUndo> {};
 struct btck_Coin : Handle<btck_Coin, Coin> {};
 struct btck_BlockHash : Handle<btck_BlockHash, uint256> {};
+struct btck_TransactionInput : Handle<btck_TransactionInput, CTxIn> {};
+struct btck_TransactionOutPoint: Handle<btck_TransactionOutPoint, COutPoint> {};
+struct btck_Txid: Handle<btck_Txid, Txid> {};
 
 btck_Transaction* btck_transaction_create(const void* raw_transaction, size_t raw_transaction_len)
 {
@@ -526,6 +529,17 @@ size_t btck_transaction_count_inputs(const btck_Transaction* transaction)
     return btck_Transaction::get(transaction)->vin.size();
 }
 
+const btck_TransactionInput* btck_transaction_get_input_at(const btck_Transaction* transaction, size_t input_index)
+{
+    assert(input_index < btck_Transaction::get(transaction)->vin.size());
+    return btck_TransactionInput::ref(&btck_Transaction::get(transaction)->vin[input_index]);
+}
+
+const btck_Txid* btck_transaction_get_txid(const btck_Transaction* transaction)
+{
+    return btck_Txid::ref(&btck_Transaction::get(transaction)->GetHash());
+}
+
 btck_Transaction* btck_transaction_copy(const btck_Transaction* transaction)
 {
     return btck_Transaction::copy(transaction);
@@ -642,6 +656,61 @@ int btck_script_pubkey_verify(const btck_ScriptPubkey* script_pubkey,
     return result ? 1 : 0;
 }
 
+btck_TransactionInput* btck_transaction_input_copy(const btck_TransactionInput* input)
+{
+    return btck_TransactionInput::copy(input);
+}
+
+const btck_TransactionOutPoint* btck_transaction_input_get_out_point(const btck_TransactionInput* input)
+{
+    return btck_TransactionOutPoint::ref(&btck_TransactionInput::get(input).prevout);
+}
+
+void btck_transaction_input_destroy(btck_TransactionInput* input)
+{
+    delete input;
+}
+
+btck_TransactionOutPoint* btck_transaction_out_point_copy(const btck_TransactionOutPoint* out_point)
+{
+    return btck_TransactionOutPoint::copy(out_point);
+}
+
+uint32_t btck_transaction_out_point_get_index(const btck_TransactionOutPoint* out_point)
+{
+    return btck_TransactionOutPoint::get(out_point).n;
+}
+
+const btck_Txid* btck_transaction_out_point_get_txid(const btck_TransactionOutPoint* out_point)
+{
+    return btck_Txid::ref(&btck_TransactionOutPoint::get(out_point).hash);
+}
+
+void btck_transaction_out_point_destroy(btck_TransactionOutPoint* out_point)
+{
+    delete out_point;
+}
+
+btck_Txid* btck_txid_copy(const btck_Txid* txid)
+{
+    return btck_Txid::copy(txid);
+}
+
+void btck_txid_to_bytes(const btck_Txid* txid, unsigned char output[32])
+{
+    std::memcpy(output, btck_Txid::get(txid).begin(), 32);
+}
+
+int btck_txid_equals(const btck_Txid* txid1, const btck_Txid* txid2)
+{
+    return btck_Txid::get(txid1) == btck_Txid::get(txid2);
+}
+
+void btck_txid_destroy(btck_Txid* txid)
+{
+    delete txid;
+}
+
 void btck_logging_set_level_category(btck_LogCategory category, btck_LogLevel level)
 {
     LOCK(cs_main);
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index 6a8196f8725..4bbd44d5fce 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -248,6 +248,22 @@ typedef struct btck_Coin btck_Coin;
  */
 typedef struct btck_BlockHash btck_BlockHash;
 
+/**
+ * Opaque data structure for holding a transaction input.
+ *
+ * Holds information on the @ref btck_TransactionOutPoint held within.
+ */
+typedef struct btck_TransactionInput btck_TransactionInput;
+
+/**
+ * Opaque data structure for holding a transaction out point.
+ *
+ * Holds the transaction id and output index it is pointing to.
+ */
+typedef struct btck_TransactionOutPoint btck_TransactionOutPoint;
+
+typedef struct btck_Txid btck_Txid;
+
 /** Current sync state passed to tip changed callbacks. */
 typedef uint8_t btck_SynchronizationState;
 #define btck_SynchronizationState_INIT_REINDEX ((btck_SynchronizationState)(0))
@@ -493,6 +509,18 @@ BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_count
 BITCOINKERNEL_API const btck_TransactionOutput* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_get_output_at(
     const btck_Transaction* transaction, size_t output_index) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Get the transaction input at the provided index. The returned
+ * transaction input is not owned and depends on the lifetime of the
+ * transaction.
+ *
+ * @param[in] transaction Non-null.
+ * @param[in] input_index The index of the transaction input to be retrieved.
+ * @return                 The transaction input
+ */
+BITCOINKERNEL_API const btck_TransactionInput* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_get_input_at(
+    const btck_Transaction* transaction, size_t input_index) BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * @brief Get the number of inputs of a transaction.
  *
@@ -502,6 +530,15 @@ BITCOINKERNEL_API const btck_TransactionOutput* BITCOINKERNEL_WARN_UNUSED_RESULT
 BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_count_inputs(
     const btck_Transaction* transaction) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Get the txid of a transaction.
+ *
+ * @param[in] transaction Non-null.
+ * @return                The txid.
+ */
+BITCOINKERNEL_API const btck_Txid* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_get_txid(
+    const btck_Transaction* transaction) BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * Destroy the transaction.
  */
@@ -1292,6 +1329,118 @@ BITCOINKERNEL_API void btck_transaction_spent_outputs_destroy(btck_TransactionSp
 
 ///@}
 
+/** @name Transaction Input
+ * Functions for working with transaction inputs.
+ */
+///@{
+
+/**
+ * @brief Copy a transaction input.
+ *
+ * @param[in] transaction_input Non-null.
+ * @return                      The copied transaction input.
+ */
+BITCOINKERNEL_API btck_TransactionInput* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_input_copy(
+    const btck_TransactionInput* transaction_input) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Get the transaction out point. The returned transaction out point is
+ * not owned and depends on the lifetime of the transaction.
+ *
+ * @param[in] transaction_input Non-null.
+ * @return                      The transaction out point.
+ */
+BITCOINKERNEL_API const btck_TransactionOutPoint* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_input_get_out_point(
+    const btck_TransactionInput* transaction_input) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Destroy the transaction input.
+ */
+BITCOINKERNEL_API void btck_transaction_input_destroy(btck_TransactionInput* transaction_input);
+
+///@}
+
+/** @name Transaction Out Point
+ * Functions for working with transaction out points.
+ */
+///@{
+
+/**
+ * @brief Copy a transaction out point.
+ *
+ * @param[in] transaction_out_point Non-null.
+ * @return                          The copied transaction out point.
+ */
+BITCOINKERNEL_API btck_TransactionOutPoint* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_out_point_copy(
+    const btck_TransactionOutPoint* transaction_out_point) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Get the output position from the out point.
+ *
+ * @param[in] transaction_out_point Non-null.
+ * @return                          The output index.
+ */
+BITCOINKERNEL_API uint32_t btck_transaction_out_point_get_index(
+    const btck_TransactionOutPoint* transaction_out_point) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Get the txid from the out point.
+ *
+ * @param[in] transaction_out_point Non-null.
+ * @return                          The txid.
+ */
+BITCOINKERNEL_API const btck_Txid* btck_transaction_out_point_get_txid(
+    const btck_TransactionOutPoint* transaction_out_point) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * Destroy the transaction out point.
+ */
+BITCOINKERNEL_API void btck_transaction_out_point_destroy(btck_TransactionOutPoint* transaction_out_point);
+
+///@}
+
+/** @name Txid
+ * Functions for working with txids.
+ */
+///@{
+
+/**
+ * @brief Copy a txid.
+ *
+ * @param[in] txid Non-null.
+ * @return         The copied txid.
+ */
+BITCOINKERNEL_API btck_Txid* BITCOINKERNEL_WARN_UNUSED_RESULT btck_txid_copy(
+    const btck_Txid* txid) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Check if two txids are equal.
+ *
+ * @param[in] txid1 Non-null.
+ * @param[in] txid2 Non-null.
+ * @return          0 if the txid is not equal.
+ */
+BITCOINKERNEL_API int btck_txid_equals(
+    const btck_Txid* txid1, const btck_Txid* txid2) BITCOINKERNEL_ARG_NONNULL(1, 2);
+
+/**
+ * @brief Serializes the txid to bytes.
+ *
+ * @param[in] txid    Non-null.
+ * @param[out] output The serialized txid.
+ */
+BITCOINKERNEL_API void btck_txid_to_bytes(
+    const btck_Txid* txid, unsigned char output[32]) BITCOINKERNEL_ARG_NONNULL(1, 2);
+
+/**
+ * Destroy the txid.
+ */
+BITCOINKERNEL_API void btck_txid_destroy(btck_Txid* txid);
+
+///@}
+
+///@}
+
 /** @name Coin
  * Functions for working with coins.
  */
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
index 749bed2e95c..ac6fcc0de1f 100644
--- a/src/kernel/bitcoinkernel_wrapper.h
+++ b/src/kernel/bitcoinkernel_wrapper.h
@@ -447,6 +447,119 @@ public:
         : Handle(view) {}
 };
 
+template <typename Derived>
+class TxidApi
+{
+private:
+    auto impl() const
+    {
+        return static_cast<const Derived*>(this)->get();
+    }
+
+    friend Derived;
+    TxidApi() = default;
+
+public:
+    bool operator==(const TxidApi& other) const
+    {
+        return btck_txid_equals(impl(), other.impl()) != 0;
+    }
+
+    bool operator!=(const TxidApi& other) const
+    {
+        return btck_txid_equals(impl(), other.impl()) == 0;
+    }
+
+    std::array<std::byte, 32> ToBytes() const
+    {
+        std::array<std::byte, 32> hash;
+        btck_txid_to_bytes(impl(), reinterpret_cast<unsigned char*>(hash.data()));
+        return hash;
+    }
+};
+
+class TxidView : public View<btck_Txid>, public TxidApi<TxidView>
+{
+public:
+    explicit TxidView(const btck_Txid* ptr) : View{ptr} {}
+};
+
+class Txid : public Handle<btck_Txid, btck_txid_copy, btck_txid_destroy>, public TxidApi<Txid>
+{
+public:
+    Txid(const TxidView& view)
+        : Handle(view) {}
+};
+
+template <typename Derived>
+class OutPointApi
+{
+private:
+    auto impl() const
+    {
+        return static_cast<const Derived*>(this)->get();
+    }
+
+    friend Derived;
+    OutPointApi() = default;
+
+public:
+    uint32_t index() const
+    {
+        return btck_transaction_out_point_get_index(impl());
+    }
+
+    TxidView Txid() const
+    {
+        return TxidView{btck_transaction_out_point_get_txid(impl())};
+    }
+};
+
+class OutPointView : public View<btck_TransactionOutPoint>, public OutPointApi<OutPointView>
+{
+public:
+    explicit OutPointView(const btck_TransactionOutPoint* ptr) : View{ptr} {}
+};
+
+class OutPoint : public Handle<btck_TransactionOutPoint, btck_transaction_out_point_copy, btck_transaction_out_point_destroy>, public OutPointApi<OutPoint>
+{
+public:
+    OutPoint(const OutPointView& view)
+        : Handle(view) {}
+};
+
+template <typename Derived>
+class TransactionInputApi
+{
+private:
+    auto impl() const
+    {
+        return static_cast<const Derived*>(this)->get();
+    }
+
+    friend Derived;
+    TransactionInputApi() = default;
+
+public:
+    OutPointView OutPoint() const
+    {
+        return OutPointView{btck_transaction_input_get_out_point(impl())};
+    }
+};
+
+class TransactionInputView : public View<btck_TransactionInput>, public TransactionInputApi<TransactionInputView>
+{
+public:
+    explicit TransactionInputView(const btck_TransactionInput* ptr) : View{ptr} {}
+};
+
+class TransactionInput : public Handle<btck_TransactionInput, btck_transaction_input_copy, btck_transaction_input_destroy>, public TransactionInputApi<TransactionInput>
+{
+public:
+    TransactionInput(const TransactionInputView& view)
+        : Handle(view) {}
+};
+
 template <typename Derived>
 class TransactionApi
 {
@@ -472,11 +585,26 @@ public:
         return TransactionOutputView{btck_transaction_get_output_at(impl(), index)};
     }
 
+    TransactionInputView GetInput(size_t index) const
+    {
+        return TransactionInputView{btck_transaction_get_input_at(impl(), index)};
+    }
+
+    TxidView Txid() const
+    {
+        return TxidView{btck_transaction_get_txid(impl())};
+    }
+
     auto Outputs() const
     {
         return Range<Derived, &TransactionApi<Derived>::CountOutputs, &TransactionApi<Derived>::GetOutput>{*static_cast<const Derived*>(this)};
     }
 
+    auto Inputs() const
+    {
+        return Range<Derived, &TransactionApi<Derived>::CountInputs, &TransactionApi<Derived>::GetInput>{*static_cast<const Derived*>(this)};
+    }
+
     std::vector<std::byte> ToBytes() const
     {
         return write_bytes(impl(), btck_transaction_to_bytes);
diff --git a/src/test/kernel/test_kernel.cpp b/src/test/kernel/test_kernel.cpp
index 07b5e5b759a..9d7cbbf0eb8 100644
--- a/src/test/kernel/test_kernel.cpp
+++ b/src/test/kernel/test_kernel.cpp
@@ -14,6 +14,7 @@
 #include <cstdint>
 #include <cstdlib>
 #include <filesystem>
+#include <format>
 #include <iostream>
 #include <memory>
 #include <optional>
@@ -61,6 +62,19 @@ std::vector<std::byte> hex_string_to_byte_vec(std::string_view hex)
     return bytes;
 }
 
+std::string byte_span_to_hex_string_reversed(std::span<const std::byte> bytes)
+{
+    std::ostringstream oss;
+
+    // Iterate in reverse order
+    for (auto it = bytes.rbegin(); it != bytes.rend(); ++it) {
+        oss << std::hex << std::setw(2) << std::setfill('0')
+            << static_cast<unsigned int>(static_cast<uint8_t>(*it));
+    }
+
+    return oss.str();
+}
+
 constexpr auto VERIFY_ALL_PRE_SEGWIT{ScriptVerificationFlags::P2SH | ScriptVerificationFlags::DERSIG |
                                      ScriptVerificationFlags::NULLDUMMY | ScriptVerificationFlags::CHECKLOCKTIMEVERIFY |
                                      ScriptVerificationFlags::CHECKSEQUENCEVERIFY};
@@ -476,6 +490,18 @@ BOOST_AUTO_TEST_CASE(btck_transaction_output)
     CheckHandle(output, output2);
 }
 
+BOOST_AUTO_TEST_CASE(btck_transaction_input)
+{
+    Transaction tx{hex_string_to_byte_vec("020000000248c03e66fd371c7033196ce24298628e59ebefa00363026044e0f35e0325a65d000000006a473044022004893432347f39beaa280e99da595681ddb20fc45010176897e6e055d716dbfa022040a9e46648a5d10c33ef7cee5e6cf4b56bd513eae3ae044f0039824b02d0f44c012102982331a52822fd9b62e9b5d120da1d248558fac3da3a3c51cd7d9c8ad3da760efeffffffb856678c6e4c3c84e39e2ca818807049d6fba274b42af3c6d3f9d4b6513212d2000000006a473044022068bcedc7fe39c9f21ad318df2c2da62c2dc9522a89c28c8420ff9d03d2e6bf7b0220132afd752754e5cb1ea2fd0ed6a38ec666781e34b0e93dc9a08f2457842cf5660121033aeb9c079ea3e08ea03556182ab520ce5c22e6b0cb95cee6435ee17144d860cdfeffffff0260d50b00000000001976a914363cc8d55ea8d0500de728ef6d63804ddddbdc9888ac67040f00000000001976a914c303bdc5064bf9c9a8b507b5496bd0987285707988ac6acb0700")};
+    TransactionInput input_0 = tx.GetInput(0);
+    TransactionInput input_1 = tx.GetInput(1);
+    CheckHandle(input_0, input_1);
+    CheckRange(tx.Inputs(), tx.CountInputs());
+    OutPoint point_0 = input_0.OutPoint();
+    OutPoint point_1 = input_1.OutPoint();
+    CheckHandle(point_0, point_1);
+}
+
 BOOST_AUTO_TEST_CASE(btck_script_verify_tests)
 {
     // Legacy transaction aca326a724eda9a461c10a876534ecd5ae7b27f10f26c3862fb996f80ea2d45d
@@ -731,6 +757,7 @@ void chainman_mainnet_validation_test(TestDirectory& test_directory)
     auto raw_block = hex_string_to_byte_vec("010000006fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000982051fd1e4ba744bbbe680e1fee14677ba1a3c3540bf7b1cdb606e857233e0e61bc6649ffff001d01e362990101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0704ffff001d0104ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac00000000");
     Block block{raw_block};
     TransactionView tx{block.GetTransaction(block.CountTransactions() - 1)};
+    BOOST_CHECK_EQUAL(byte_span_to_hex_string_reversed(tx.Txid().ToBytes()), "0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098");
     BOOST_CHECK_EQUAL(tx.CountInputs(), 1);
     Transaction tx2 = tx;
     BOOST_CHECK_EQUAL(tx2.CountInputs(), 1);
@@ -869,6 +896,48 @@ BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests)
     auto read_block_2 = chainman->ReadBlock(tip_2).value();
     check_equal(read_block_2.ToBytes(), as_bytes(REGTEST_BLOCK_DATA[REGTEST_BLOCK_DATA.size() - 2]));
 
+    Txid txid = read_block.Transactions()[0].Txid();
+    Txid txid_2 = read_block_2.Transactions()[0].Txid();
+    BOOST_CHECK(txid != txid_2);
+    BOOST_CHECK(txid == txid);
+    CheckHandle(txid, txid_2);
+
+    auto find_transaction = [&chainman](const TxidView& target_txid) -> std::optional<Transaction> {
+        for (const auto block_tree_entry : chainman->GetChain().Entries()) {
+            auto block{chainman->ReadBlock(block_tree_entry)};
+            for (const auto transaction : block->Transactions()) {
+                if (transaction.Txid() == target_txid) {
+                    return transaction;
+                }
+            }
+        }
+        return std::nullopt;
+    };
+
+    for (const auto block_tree_entry : chainman->GetChain().Entries()) {
+        auto block{chainman->ReadBlock(block_tree_entry)};
+        for (const auto transaction : block->Transactions()) {
+            std::vector<TransactionInput> inputs;
+            std::vector<TransactionOutput> spent_outputs;
+            for (const auto input : transaction.Inputs()) {
+                OutPointView point = input.OutPoint();
+                if (point.index() == std::numeric_limits<uint32_t>::max()) {
+                    continue;
+                }
+                inputs.emplace_back(input);
+                BOOST_CHECK(point.Txid() != transaction.Txid());
+                Transaction tx = *find_transaction(point.Txid());
+                BOOST_CHECK(point.Txid() == tx.Txid());
+                spent_outputs.emplace_back(tx.GetOutput(point.index()));
+            }
+            BOOST_CHECK(inputs.size() == spent_outputs.size());
+            ScriptVerifyStatus status = ScriptVerifyStatus::OK;
+            for (size_t i{0}; i < inputs.size(); ++i) {
+                BOOST_CHECK(spent_outputs[i].GetScriptPubkey().Verify(spent_outputs[i].Amount(), transaction, spent_outputs, i, ScriptVerificationFlags::ALL, status));
+            }
+        }
+    }
+
     BlockSpentOutputs block_spent_outputs{chainman->ReadBlockSpentOutputs(tip)};
     BlockSpentOutputs block_spent_outputs_prev{chainman->ReadBlockSpentOutputs(*tip.GetPrevious())};
     CheckHandle(block_spent_outputs, block_spent_outputs_prev);

From 79d3f30ebe11adee1d4ef372484098ef0b09e526 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Fri, 14 Jun 2024 18:33:08 +0200
Subject: [PATCH 21/24] kernel: Add pure kernel bitcoin-chainstate

Re-write the bitcoin-chainstate utility by only using the kernel C++ API
header instead of internal Bitcoin Core code.
---
 src/bitcoin-chainstate.cpp        | 406 +++++++++++++-----------------
 test/lint/test_runner/src/main.rs |   1 +
 2 files changed, 171 insertions(+), 236 deletions(-)

diff --git a/src/bitcoin-chainstate.cpp b/src/bitcoin-chainstate.cpp
index 46e6f06e27f..6c3bd9cfe01 100644
--- a/src/bitcoin-chainstate.cpp
+++ b/src/bitcoin-chainstate.cpp
@@ -1,53 +1,135 @@
-// Copyright (c) 2022 The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-//
-// The bitcoin-chainstate executable serves to surface the dependencies required
-// by a program wishing to use Bitcoin Core's consensus engine as it is right
-// now.
-//
-// DEVELOPER NOTE: Since this is a "demo-only", experimental, etc. executable,
-//                 it may diverge from Bitcoin Core's coding style.
-//
-// It is part of the libbitcoinkernel project.
-
-#include <kernel/chainparams.h>
-#include <kernel/chainstatemanager_opts.h>
-#include <kernel/checks.h>
-#include <kernel/context.h>
-#include <kernel/warning.h>
-
-#include <consensus/validation.h>
-#include <core_io.h>
-#include <kernel/caches.h>
-#include <logging.h>
-#include <node/blockstorage.h>
-#include <node/chainstate.h>
-#include <random.h>
-#include <script/sigcache.h>
-#include <util/chaintype.h>
-#include <util/fs.h>
-#include <util/signalinterrupt.h>
-#include <util/task_runner.h>
-#include <util/translation.h>
-#include <validation.h>
-#include <validationinterface.h>
+#include <kernel/bitcoinkernel_wrapper.h>
 
 #include <cassert>
-#include <cstdint>
-#include <functional>
-#include <iosfwd>
-#include <memory>
+#include <charconv>
+#include <filesystem>
+#include <iostream>
+#include <optional>
 #include <string>
+#include <string_view>
+#include <vector>
+
+using namespace btck;
+
+std::vector<std::byte> hex_string_to_byte_vec(std::string_view hex)
+{
+    std::vector<std::byte> bytes;
+    bytes.reserve(hex.length() / 2);
+
+    for (size_t i{0}; i < hex.length(); i += 2) {
+        uint8_t byte_value;
+        auto [ptr, ec] = std::from_chars(hex.data() + i, hex.data() + i + 2, byte_value, 16);
+
+        if (ec != std::errc{} || ptr != hex.data() + i + 2) {
+            throw std::invalid_argument("Invalid hex character");
+        }
+        bytes.push_back(static_cast<std::byte>(byte_value));
+    }
+    return bytes;
+}
+
+class KernelLog
+{
+public:
+    void LogMessage(std::string_view message)
+    {
+        std::cout << "kernel: " << message;
+    }
+};
+
+class TestValidationInterface : public ValidationInterface<TestValidationInterface>
+{
+public:
+    TestValidationInterface() = default;
+
+    std::optional<std::string> m_expected_valid_block = std::nullopt;
+
+    void BlockChecked(const Block block, const BlockValidationState state) override
+    {
+        auto mode{state.GetValidationMode()};
+        switch (mode) {
+        case ValidationMode::VALID: {
+            std::cout << "Valid block" << std::endl;
+            return;
+        }
+        case ValidationMode::INVALID: {
+            std::cout << "Invalid block: ";
+            auto result{state.GetBlockValidationResult()};
+            switch (result) {
+            case BlockValidationResult::UNSET:
+                std::cout << "initial value. Block has not yet been rejected" << std::endl;
+                break;
+            case BlockValidationResult::HEADER_LOW_WORK:
+                std::cout << "the block header may be on a too-little-work chain" << std::endl;
+                break;
+            case BlockValidationResult::CONSENSUS:
+                std::cout << "invalid by consensus rules (excluding any below reasons)" << std::endl;
+                break;
+            case BlockValidationResult::CACHED_INVALID:
+                std::cout << "this block was cached as being invalid and we didn't store the reason why" << std::endl;
+                break;
+            case BlockValidationResult::INVALID_HEADER:
+                std::cout << "invalid proof of work or time too old" << std::endl;
+                break;
+            case BlockValidationResult::MUTATED:
+                std::cout << "the block's data didn't match the data committed to by the PoW" << std::endl;
+                break;
+            case BlockValidationResult::MISSING_PREV:
+                std::cout << "We don't have the previous block the checked one is built on" << std::endl;
+                break;
+            case BlockValidationResult::INVALID_PREV:
+                std::cout << "A block this one builds on is invalid" << std::endl;
+                break;
+            case BlockValidationResult::TIME_FUTURE:
+                std::cout << "block timestamp was > 2 hours in the future (or our clock is bad)" << std::endl;
+                break;
+            }
+            return;
+        }
+        case ValidationMode::INTERNAL_ERROR: {
+            std::cout << "Internal error" << std::endl;
+            return;
+        }
+        }
+    }
+};
+
+class TestKernelNotifications : public KernelNotifications<TestKernelNotifications>
+{
+public:
+    void BlockTipHandler(SynchronizationState, const BlockTreeEntry, double) override
+    {
+        std::cout << "Block tip changed" << std::endl;
+    }
+
+    void ProgressHandler(std::string_view title, int progress_percent, bool resume_possible) override
+    {
+        std::cout << "Made progress: " << title << " " << progress_percent << "%" << std::endl;
+    }
+
+    void WarningSetHandler(Warning warning, std::string_view message) override
+    {
+        std::cout << message << std::endl;
+    }
+
+    void WarningUnsetHandler(Warning warning) override
+    {
+        std::cout << "Warning unset: " << static_cast<std::underlying_type_t<Warning>>(warning) << std::endl;
+    }
+
+    void FlushErrorHandler(std::string_view error) override
+    {
+        std::cout << error << std::endl;
+    }
+
+    void FatalErrorHandler(std::string_view error) override
+    {
+        std::cout << error << std::endl;
+    }
+};
 
 int main(int argc, char* argv[])
 {
-    // We do not enable logging for this app, so explicitly disable it.
-    // To enable logging instead, replace with:
-    //    LogInstance().m_print_to_console = true;
-    //    LogInstance().StartLogging();
-    LogInstance().DisableLogging();
-
     // SETUP: Argument parsing and handling
     if (argc != 2) {
         std::cerr
@@ -58,213 +140,65 @@ int main(int argc, char* argv[])
             << "           BREAK IN FUTURE VERSIONS. DO NOT USE ON YOUR ACTUAL DATADIR." << std::endl;
         return 1;
     }
-    fs::path abs_datadir{fs::absolute(argv[1])};
-    fs::create_directories(abs_datadir);
+    std::filesystem::path abs_datadir{std::filesystem::absolute(argv[1])};
+    std::filesystem::create_directories(abs_datadir);
 
-
-    // SETUP: Context
-    kernel::Context kernel_context{};
-    // We can't use a goto here, but we can use an assert since none of the
-    // things instantiated so far requires running the epilogue to be torn down
-    // properly
-    assert(kernel::SanityChecks(kernel_context));
-
-    ValidationSignals validation_signals{std::make_unique<util::ImmediateTaskRunner>()};
-
-    class KernelNotifications : public kernel::Notifications
-    {
-    public:
-        kernel::InterruptResult blockTip(SynchronizationState, const CBlockIndex&, double) override
-        {
-            std::cout << "Block tip changed" << std::endl;
-            return {};
-        }
-        void headerTip(SynchronizationState, int64_t height, int64_t timestamp, bool presync) override
-        {
-            std::cout << "Header tip changed: " << height << ", " << timestamp << ", " << presync << std::endl;
-        }
-        void progress(const bilingual_str& title, int progress_percent, bool resume_possible) override
-        {
-            std::cout << "Progress: " << title.original << ", " << progress_percent << ", " << resume_possible << std::endl;
-        }
-        void warningSet(kernel::Warning id, const bilingual_str& message) override
-        {
-            std::cout << "Warning " << static_cast<int>(id) << " set: " << message.original << std::endl;
-        }
-        void warningUnset(kernel::Warning id) override
-        {
-            std::cout << "Warning " << static_cast<int>(id) << " unset" << std::endl;
-        }
-        void flushError(const bilingual_str& message) override
-        {
-            std::cerr << "Error flushing block data to disk: " << message.original << std::endl;
-        }
-        void fatalError(const bilingual_str& message) override
-        {
-            std::cerr << "Error: " << message.original << std::endl;
-        }
+    btck_LoggingOptions logging_options = {
+        .log_timestamps = true,
+        .log_time_micros = false,
+        .log_threadnames = false,
+        .log_sourcelocations = false,
+        .always_print_category_levels = true,
     };
-    auto notifications = std::make_unique<KernelNotifications>();
 
-    kernel::CacheSizes cache_sizes{DEFAULT_KERNEL_CACHE};
+    Logger logger{std::make_unique<KernelLog>(KernelLog{}), logging_options};
 
-    // SETUP: Chainstate
-    auto chainparams = CChainParams::Main();
-    const ChainstateManager::Options chainman_opts{
-        .chainparams = *chainparams,
-        .datadir = abs_datadir,
-        .notifications = *notifications,
-        .signals = &validation_signals,
-    };
-    const node::BlockManager::Options blockman_opts{
-        .chainparams = chainman_opts.chainparams,
-        .blocks_dir = abs_datadir / "blocks",
-        .notifications = chainman_opts.notifications,
-        .block_tree_db_params = DBParams{
-            .path = abs_datadir / "blocks" / "index",
-            .cache_bytes = cache_sizes.block_tree_db,
-        },
-    };
-    util::SignalInterrupt interrupt;
-    ChainstateManager chainman{interrupt, chainman_opts, blockman_opts};
+    ContextOptions options{};
+    ChainParams params{ChainType::MAINNET};
+    options.SetChainParams(params);
 
-    node::ChainstateLoadOptions options;
-    auto [status, error] = node::LoadChainstate(chainman, cache_sizes, options);
-    if (status != node::ChainstateLoadStatus::SUCCESS) {
-        std::cerr << "Failed to load Chain state from your datadir." << std::endl;
-        goto epilogue;
-    } else {
-        std::tie(status, error) = node::VerifyLoadedChainstate(chainman, options);
-        if (status != node::ChainstateLoadStatus::SUCCESS) {
-            std::cerr << "Failed to verify loaded Chain state from your datadir." << std::endl;
-            goto epilogue;
-        }
+    options.SetNotifications(std::make_shared<TestKernelNotifications>());
+    options.SetValidationInterface(std::make_shared<TestValidationInterface>());
+
+    Context context{options};
+
+    ChainstateManagerOptions chainman_opts{context, abs_datadir.string(), (abs_datadir / "blocks").string()};
+    chainman_opts.SetWorkerThreads(4);
+
+    std::unique_ptr<ChainMan> chainman;
+    try {
+        chainman = std::make_unique<ChainMan>(context, chainman_opts);
+    } catch (std::exception&) {
+        std::cerr << "Failed to instantiate ChainMan, exiting" << std::endl;
+        return 1;
     }
 
-    for (Chainstate* chainstate : WITH_LOCK(::cs_main, return chainman.GetAll())) {
-        BlockValidationState state;
-        if (!chainstate->ActivateBestChain(state, nullptr)) {
-            std::cerr << "Failed to connect best block (" << state.ToString() << ")" << std::endl;
-            goto epilogue;
-        }
-    }
-
-    // Main program logic starts here
-    std::cout
-        << "Hello! I'm going to print out some information about your datadir." << std::endl
-        << "\t"
-        << "Path: " << abs_datadir << std::endl;
-    {
-        LOCK(chainman.GetMutex());
-        std::cout
-        << "\t" << "Blockfiles Indexed: " << std::boolalpha << chainman.m_blockman.m_blockfiles_indexed.load() << std::noboolalpha << std::endl
-        << "\t" << "Snapshot Active: " << std::boolalpha << chainman.IsSnapshotActive() << std::noboolalpha << std::endl
-        << "\t" << "Active Height: " << chainman.ActiveHeight() << std::endl
-        << "\t" << "Active IBD: " << std::boolalpha << chainman.IsInitialBlockDownload() << std::noboolalpha << std::endl;
-        CBlockIndex* tip = chainman.ActiveTip();
-        if (tip) {
-            std::cout << "\t" << tip->ToString() << std::endl;
-        }
-    }
+    std::cout << "Enter the block you want to validate on the next line:" << std::endl;
 
     for (std::string line; std::getline(std::cin, line);) {
         if (line.empty()) {
-            std::cerr << "Empty line found" << std::endl;
-            break;
+            std::cerr << "Empty line found, try again:" << std::endl;
+            continue;
         }
 
-        std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
-        CBlock& block = *blockptr;
-
-        if (!DecodeHexBlk(block, line)) {
-            std::cerr << "Block decode failed" << std::endl;
-            break;
+        auto raw_block{hex_string_to_byte_vec(line)};
+        std::unique_ptr<Block> block;
+        try {
+            block = std::make_unique<Block>(raw_block);
+        } catch (std::exception&) {
+            std::cerr << "Block decode failed, try again:" << std::endl;
+            continue;
         }
 
-        {
-            LOCK(cs_main);
-            const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock);
-            if (pindex) {
-                chainman.UpdateUncommittedBlockStructures(block, pindex);
-            }
+        bool new_block = false;
+        bool accepted = chainman->ProcessBlock(*block, &new_block);
+        if (accepted) {
+            std::cerr << "Block has not yet been rejected" << std::endl;
+        } else {
+            std::cerr << "Block was not accepted" << std::endl;
         }
-
-        // Adapted from rpc/mining.cpp
-        class submitblock_StateCatcher final : public CValidationInterface
-        {
-        public:
-            uint256 hash;
-            bool found;
-            BlockValidationState state;
-
-            explicit submitblock_StateCatcher(const uint256& hashIn) : hash(hashIn), found(false), state() {}
-
-        protected:
-            void BlockChecked(const std::shared_ptr<const CBlock>& block, const BlockValidationState& stateIn) override
-            {
-                if (block->GetHash() != hash)
-                    return;
-                found = true;
-                state = stateIn;
-            }
-        };
-
-        bool new_block;
-        auto sc = std::make_shared<submitblock_StateCatcher>(block.GetHash());
-        validation_signals.RegisterSharedValidationInterface(sc);
-        bool accepted = chainman.ProcessNewBlock(blockptr, /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/&new_block);
-        validation_signals.UnregisterSharedValidationInterface(sc);
-        if (!new_block && accepted) {
-            std::cerr << "duplicate" << std::endl;
-            break;
-        }
-        if (!sc->found) {
-            std::cerr << "inconclusive" << std::endl;
-            break;
-        }
-        std::cout << sc->state.ToString() << std::endl;
-        switch (sc->state.GetResult()) {
-        case BlockValidationResult::BLOCK_RESULT_UNSET:
-            std::cerr << "initial value. Block has not yet been rejected" << std::endl;
-            break;
-        case BlockValidationResult::BLOCK_HEADER_LOW_WORK:
-            std::cerr << "the block header may be on a too-little-work chain" << std::endl;
-            break;
-        case BlockValidationResult::BLOCK_CONSENSUS:
-            std::cerr << "invalid by consensus rules (excluding any below reasons)" << std::endl;
-            break;
-        case BlockValidationResult::BLOCK_CACHED_INVALID:
-            std::cerr << "this block was cached as being invalid and we didn't store the reason why" << std::endl;
-            break;
-        case BlockValidationResult::BLOCK_INVALID_HEADER:
-            std::cerr << "invalid proof of work or time too old" << std::endl;
-            break;
-        case BlockValidationResult::BLOCK_MUTATED:
-            std::cerr << "the block's data didn't match the data committed to by the PoW" << std::endl;
-            break;
-        case BlockValidationResult::BLOCK_MISSING_PREV:
-            std::cerr << "We don't have the previous block the checked one is built on" << std::endl;
-            break;
-        case BlockValidationResult::BLOCK_INVALID_PREV:
-            std::cerr << "A block this one builds on is invalid" << std::endl;
-            break;
-        case BlockValidationResult::BLOCK_TIME_FUTURE:
-            std::cerr << "block timestamp was > 2 hours in the future (or our clock is bad)" << std::endl;
-            break;
-        }
-    }
-
-epilogue:
-    // Without this precise shutdown sequence, there will be a lot of nullptr
-    // dereferencing and UB.
-    validation_signals.FlushBackgroundCallbacks();
-    {
-        LOCK(cs_main);
-        for (Chainstate* chainstate : chainman.GetAll()) {
-            if (chainstate->CanFlushToDisk()) {
-                chainstate->ForceFlushStateToDisk();
-                chainstate->ResetCoinsViews();
-            }
+        if (!new_block) {
+            std::cerr << "Block is a duplicate" << std::endl;
         }
     }
 }
diff --git a/test/lint/test_runner/src/main.rs b/test/lint/test_runner/src/main.rs
index 53d24ca4960..fc00124ae23 100644
--- a/test/lint/test_runner/src/main.rs
+++ b/test/lint/test_runner/src/main.rs
@@ -374,6 +374,7 @@ fn lint_std_filesystem() -> LintResult {
             ":(exclude)src/ipc/libmultiprocess/",
             ":(exclude)src/util/fs.h",
             ":(exclude)src/test/kernel/test_kernel.cpp",
+            ":(exclude)src/bitcoin-chainstate.cpp",
         ])
         .status()
         .expect("command error")

From 2db540a17345e0e38667f801decc10a263335dff Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Mon, 28 Jul 2025 16:26:44 +0200
Subject: [PATCH 22/24] kernel: Allowing reducing exports

Now that an API has been defined, remove the override for symbol
visibility of the library. It is now possible to build the library with
reduced exports.
---
 src/kernel/CMakeLists.txt | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/src/kernel/CMakeLists.txt b/src/kernel/CMakeLists.txt
index 7b2f3c7d11f..1db7ead0950 100644
--- a/src/kernel/CMakeLists.txt
+++ b/src/kernel/CMakeLists.txt
@@ -96,16 +96,6 @@ target_link_libraries(bitcoinkernel
 
 target_include_directories(bitcoinkernel PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src/leveldb/include>)
 
-# libbitcoinkernel requires default symbol visibility, explicitly
-# specify that here so that things still work even when user
-# configures with -DREDUCE_EXPORTS=ON
-#
-# Note this is a quick hack that will be removed as we
-# incrementally define what to export from the library.
-set_target_properties(bitcoinkernel PROPERTIES
-  CXX_VISIBILITY_PRESET default
-)
-
 # Add a convenience libbitcoinkernel target as a synonym for bitcoinkernel.
 add_custom_target(libbitcoinkernel)
 add_dependencies(libbitcoinkernel bitcoinkernel)

From 1db7bde6d214d5ec340ff5c7959473cbc935c9b9 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Wed, 26 Mar 2025 12:09:28 +0100
Subject: [PATCH 23/24] kernel: Add Purpose section to header documentation

---
 src/kernel/bitcoinkernel.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
index 4bbd44d5fce..1ad35eb53fd 100644
--- a/src/kernel/bitcoinkernel.h
+++ b/src/kernel/bitcoinkernel.h
@@ -48,6 +48,14 @@ extern "C" {
 /**
  * @page remarks Remarks
  *
+ * @section purpose Purpose
+ *
+ * This header currently exposes an API for interacting with parts of Bitcoin
+ * Core's consensus code. Users can validate blocks, iterate the block index,
+ * read block und undo data from disk, and validate scripts. The header is
+ * unversioned and not stable yet. Users should expect breaking changes. It is
+ * also not yet included in releases of Bitcoin Core.
+ *
  * @section context Context
  *
  * The library provides a built-in static constant kernel context. This static

From 4fce466d1a3e345836434f8fb375980f626981f1 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Tue, 8 Apr 2025 16:51:37 +0200
Subject: [PATCH 24/24] kernel: Fix bitcoin-chainstate for windows

And turn it on in the CI.
---
 .github/workflows/ci.yml   |  3 ++-
 src/bitcoin-chainstate.cpp | 25 +++++++++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 7e4dea822f2..5a772b11ae9 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -202,7 +202,7 @@ jobs:
         job-type: [standard, fuzz]
         include:
           - job-type: standard
-            generate-options: '-DBUILD_GUI=ON -DWITH_ZMQ=ON -DBUILD_BENCH=ON -DBUILD_KERNEL_LIB=ON -DWERROR=ON'
+            generate-options: '-DBUILD_GUI=ON -DWITH_ZMQ=ON -DBUILD_BENCH=ON -DBUILD_KERNEL_LIB=ON -DBUILD_UTIL_CHAINSTATE=ON -DBUILD_KERNEL_TEST=OFF -DWERROR=ON'
             job-name: 'Windows native, VS 2022'
           - job-type: fuzz
             generate-options: '-DVCPKG_MANIFEST_NO_DEFAULT_FEATURES=ON -DVCPKG_MANIFEST_FEATURES="wallet" -DBUILD_GUI=OFF -DBUILD_FOR_FUZZING=ON -DWERROR=ON'
@@ -307,6 +307,7 @@ jobs:
           BITCOINTX: '${{ github.workspace }}\build\bin\Release\bitcoin-tx.exe'
           BITCOINUTIL: '${{ github.workspace }}\build\bin\Release\bitcoin-util.exe'
           BITCOINWALLET: '${{ github.workspace }}\build\bin\Release\bitcoin-wallet.exe'
+          BITCOINCHAINSTATE: '${{ github.workspace }}\build\bin\Release\bitcoin-chainstate.exe'
           TEST_RUNNER_EXTRA: ${{ github.event_name != 'pull_request' && '--extended' || '' }}
         run: py -3 test/functional/test_runner.py --jobs $NUMBER_OF_PROCESSORS --ci --quiet --tmpdirprefix="${RUNNER_TEMP}" --combinedlogslen=99999999 --timeout-factor=${TEST_RUNNER_TIMEOUT_FACTOR} ${TEST_RUNNER_EXTRA}
 
diff --git a/src/bitcoin-chainstate.cpp b/src/bitcoin-chainstate.cpp
index 6c3bd9cfe01..24127d0764f 100644
--- a/src/bitcoin-chainstate.cpp
+++ b/src/bitcoin-chainstate.cpp
@@ -9,6 +9,15 @@
 #include <string_view>
 #include <vector>
 
+#ifdef WIN32
+// clang-format off
+#include <windows.h>
+// clang-format on
+#include <codecvt>
+#include <locale>
+#include <shellapi.h>
+#endif
+
 using namespace btck;
 
 std::vector<std::byte> hex_string_to_byte_vec(std::string_view hex)
@@ -140,6 +149,22 @@ int main(int argc, char* argv[])
             << "           BREAK IN FUTURE VERSIONS. DO NOT USE ON YOUR ACTUAL DATADIR." << std::endl;
         return 1;
     }
+
+#ifdef WIN32
+    int win_argc;
+    wchar_t** wargv = CommandLineToArgvW(GetCommandLineW(), &win_argc);
+    std::vector<std::string> utf8_args(win_argc);
+    std::vector<char*> win_argv(win_argc);
+    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t> utf8_cvt;
+    for (int i = 0; i < win_argc; i++) {
+        utf8_args[i] = utf8_cvt.to_bytes(wargv[i]);
+        win_argv[i] = &utf8_args[i][0];
+    }
+    LocalFree(wargv);
+    argc = win_argc;
+    argv = win_argv.data();
+#endif
+
     std::filesystem::path abs_datadir{std::filesystem::absolute(argv[1])};
     std::filesystem::create_directories(abs_datadir);