diff --git a/.gitignore b/.gitignore index 27ff8d6a..a3b96d4b 100644 --- a/.gitignore +++ b/.gitignore @@ -31,6 +31,7 @@ llvm/ # Generated test inputs tests/magia/mesh/gemm/*/include/* +tests/magia/mesh/mm_generator/include/* # Editor .vscode/ diff --git a/CMakeLists.txt b/CMakeLists.txt index 2ac0bd8e..55c07064 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -88,6 +88,7 @@ add_subdirectory(targets) add_subdirectory(hal) # add_subdirectory(devices) add_subdirectory(drivers) +add_subdirectory(mglib) ################################################################################ # Testing # diff --git a/Makefile b/Makefile index 7895be78..ce9584ae 100644 --- a/Makefile +++ b/Makefile @@ -292,17 +292,23 @@ gvsoc_init: git fetch origin $(GVSOC_GVRUN_COMMIT) && \ git checkout $(GVSOC_GVRUN_COMMIT) +# Set TORCH=1 to also install the "gemm" extra (torch, CPU build via uv). +TORCH ?= 0 +ifeq ($(TORCH),1) +PIP_EXTRAS := [gemm] +endif + gvsoc_uv: uv venv --python 3.12 gvsoc_venv && \ source gvsoc_venv/bin/activate && \ - uv pip install . + uv pip install .$(PIP_EXTRAS) gvsoc_venv: eval "$(pyenv init -)" && \ pyenv local 3.12 && \ python -m venv gvsoc_venv && \ source gvsoc_venv/bin/activate && \ - pip install . + pip install .$(PIP_EXTRAS) llvm: mkdir -p $(LLVM_DIR) diff --git a/README.md b/README.md index 1a70a49c..9a21546b 100644 --- a/README.md +++ b/README.md @@ -32,6 +32,12 @@ The following steps assume the default target platform, `magia_v2`, on which Spa From the SDK's root directory. If you have done it correctly, you'll see a "(gvsoc_venv)" preceding your terminal command line. + If you intend to generate new GEMM tests (`tests/magia/mesh/mm_generator`, which relies on PyTorch), pass `TORCH=1` to also install PyTorch (CPU build) into the environment: + + `make gvsoc_uv TORCH=1` (or `make gvsoc_pyenv TORCH=1`) + + This is not needed to build or run the existing tests, so it is disabled by default to keep the environment lightweight. + 1. RISC-V GCC toolchain: make sure it is installed and visible in the `$PATH` environment variable. You can check if and where the compiler is installed by running the following command on your root (`/`) directory: `find . ! -readable -prune -o -name "riscv32-unknown-elf-gcc" -print` diff --git a/drivers/eventunit32/include/eventunit32.h b/drivers/eventunit32/include/eventunit32.h index aee3b503..40999cd9 100644 --- a/drivers/eventunit32/include/eventunit32.h +++ b/drivers/eventunit32/include/eventunit32.h @@ -7,4 +7,64 @@ #pragma once -#include "eventunit.h" \ No newline at end of file +#include +#include "eventunit.h" +#include "regs/tile_ctrl.h" // EU_*_MASK +#include "utils/eu_isa_utils.h" // eu_wait_events() +#include "utils/performance_utils.h" // stnl_cmp_f() + +/** + * @brief Wait for RedMulE completion using specified mode + * @param mode Wait mode (polling, WFE, etc.) + * @return Non-zero if RedMulE completed, 0 if timeout/error + */ +static inline __attribute__((always_inline)) uint32_t eu32_redmule_wait(eu_controller_t *ctrl, + eu_wait_mode_t mode) +{ + uint32_t retval = eu_wait_events(EU_REDMULE_DONE_MASK, mode, 1000000); +#if PROFILE_CMP == 1 + stnl_cmp_f(); +#endif + return retval; // 1M cycle timeout +} + +/** + * @brief Wait for any iDMA completion using specified mode + * @param mode Wait mode (polling, WFE, etc.) + * @return Non-zero if any iDMA completed, 0 if timeout/error + */ +static inline __attribute__((always_inline)) uint32_t eu32_idma_wait(eu_controller_t *ctrl, + eu_wait_mode_t mode) +{ + return eu_wait_events(EU_IDMA_ALL_DONE_MASK, mode, 1000000); // 1M cycle timeout +} + +/** + * @brief Wait for L2->L1 (AXI2OBI) completion specifically + * @param mode Wait mode (polling, WFE, etc.) + * @return Non-zero if L2->L1 completed, 0 if timeout/error + */ +static inline __attribute__((always_inline)) uint32_t eu32_idma_wait_a2o(eu_controller_t *ctrl, + eu_wait_mode_t mode) +{ + uint32_t retval = eu_wait_events(EU_IDMA_A2O_DONE_MASK, mode, 1000000); +#if PROFILE_CMI == 1 + stnl_cmi_f(); +#endif + return retval; // 1M cycle timeout +} + +/** + * @brief Wait for L1->L2 (OBI2AXI) completion specifically + * @param mode Wait mode (polling, WFE, etc.) + * @return Non-zero if L1->L2 completed, 0 if timeout/error + */ +static inline __attribute__((always_inline)) uint32_t eu32_idma_wait_o2a(eu_controller_t *ctrl, + eu_wait_mode_t mode) +{ + uint32_t retval = eu_wait_events(EU_IDMA_O2A_DONE_MASK, mode, 1000000); +#if PROFILE_CMO == 1 + stnl_cmo_f(); +#endif + return retval; // 1M cycle timeout +} \ No newline at end of file diff --git a/drivers/eventunit32/src/eventunit32.c b/drivers/eventunit32/src/eventunit32.c index a43cc8c6..edbe0b3d 100644 --- a/drivers/eventunit32/src/eventunit32.c +++ b/drivers/eventunit32/src/eventunit32.c @@ -50,20 +50,6 @@ void eu32_redmule_init(eu_controller_t *ctrl, uint32_t enable_irq) } } -/** - * @brief Wait for RedMulE completion using specified mode - * @param mode Wait mode (polling, WFE, etc.) - * @return Non-zero if RedMulE completed, 0 if timeout/error - */ -uint32_t eu32_redmule_wait(eu_controller_t *ctrl, eu_wait_mode_t mode) -{ - uint32_t retval = eu_wait_events(EU_REDMULE_DONE_MASK, mode, 1000000); -#if PROFILE_CMP == 1 - stnl_cmp_f(); -#endif - return retval; // 1M cycle timeout -} - /** * @brief Check if RedMulE is currently busy * @return Non-zero if RedMulE is busy @@ -101,16 +87,6 @@ void eu32_idma_init(eu_controller_t *ctrl, uint32_t enable_irq) } } -/** - * @brief Wait for any iDMA completion using specified mode - * @param mode Wait mode (polling, WFE, etc.) - * @return Non-zero if any iDMA completed, 0 if timeout/error - */ -uint32_t eu32_idma_wait(eu_controller_t *ctrl, eu_wait_mode_t mode) -{ - return eu_wait_events(EU_IDMA_ALL_DONE_MASK, mode, 1000000); // 1M cycle timeout -} - /** * @brief Wait for specific iDMA direction completion * @param direction 0 = L2->L1 (A2O), 1 = L1->L2 (O2A) @@ -132,33 +108,9 @@ uint32_t eu32_idma_wait_direction(eu_controller_t *ctrl, uint32_t direction, eu_ return retval; // 1M cycle timeout } -/** - * @brief Wait for L2->L1 (AXI2OBI) completion specifically - * @param mode Wait mode (polling, WFE, etc.) - * @return Non-zero if L2->L1 completed, 0 if timeout/error - */ -uint32_t eu32_idma_wait_a2o(eu_controller_t *ctrl, eu_wait_mode_t mode) -{ - uint32_t retval = eu_wait_events(EU_IDMA_A2O_DONE_MASK, mode, 1000000); -#if PROFILE_CMI == 1 - stnl_cmi_f(); -#endif - return retval; -} - -/** - * @brief Wait for L1->L2 (OBI2AXI) completion specifically - * @param mode Wait mode (polling, WFE, etc.) - * @return Non-zero if L1->L2 completed, 0 if timeout/error - */ -uint32_t eu32_idma_wait_o2a(eu_controller_t *ctrl, eu_wait_mode_t mode) -{ - uint32_t retval = eu_wait_events(EU_IDMA_O2A_DONE_MASK, mode, 1000000); -#if PROFILE_CMO == 1 - stnl_cmo_f(); -#endif - return retval; -} +// eu32_idma_wait_a2o / eu32_idma_wait_o2a are now static inline (see +// eventunit32.h), so they cannot be alias targets; the external symbols are +// exposed via thin wrappers further down for legacy/test callers. /** * @brief Check if any iDMA transfer has completed @@ -344,14 +296,28 @@ extern void eu_init(eu_controller_t *ctrl) __attribute__((alias("eu32_init"), used, visibility("default"))); extern void eu_redmule_init(eu_controller_t *ctrl, uint32_t enable_irq) __attribute__((alias("eu32_redmule_init"), used, visibility("default"))); -extern uint32_t eu_redmule_wait(eu_controller_t *ctrl, eu_wait_mode_t mode) - __attribute__((alias("eu32_redmule_wait"), used, visibility("default"))); +// eu32_redmule_wait is now a static inline (see eventunit32.h), so it cannot be an +// alias target; expose the external symbol via a thin wrapper for legacy/test callers. +uint32_t __attribute__((used, visibility("default"))) eu_redmule_wait(eu_controller_t *ctrl, + eu_wait_mode_t mode) +{ + return eu32_redmule_wait(ctrl, mode); +} extern void eu_idma_init(eu_controller_t *ctrl, uint32_t enable_irq) __attribute__((alias("eu32_idma_init"), used, visibility("default"))); -extern uint32_t eu_idma_wait_a2o(eu_controller_t *ctrl, eu_wait_mode_t mode) - __attribute__((alias("eu32_idma_wait_a2o"), used, visibility("default"))); -extern uint32_t eu_idma_wait_o2a(eu_controller_t *ctrl, eu_wait_mode_t mode) - __attribute__((alias("eu32_idma_wait_o2a"), used, visibility("default"))); +// eu32_idma_wait_a2o / eu32_idma_wait_o2a are now static inlines (see +// eventunit32.h), so they cannot be alias targets; expose the external symbols +// via thin wrappers for legacy/test callers. +uint32_t __attribute__((used, visibility("default"))) eu_idma_wait_a2o(eu_controller_t *ctrl, + eu_wait_mode_t mode) +{ + return eu32_idma_wait_a2o(ctrl, mode); +} +uint32_t __attribute__((used, visibility("default"))) eu_idma_wait_o2a(eu_controller_t *ctrl, + eu_wait_mode_t mode) +{ + return eu32_idma_wait_o2a(ctrl, mode); +} extern void eu_fsync_init(eu_controller_t *ctrl, uint32_t enable_irq) __attribute__((alias("eu32_fsync_init"), used, visibility("default"))); extern uint32_t eu_fsync_wait(eu_controller_t *ctrl, eu_wait_mode_t mode) @@ -397,13 +363,13 @@ extern uint32_t eu_spatz_is_done(eu_controller_t *ctrl) eu_controller_api_t eu_api = { .init = eu32_init, .redmule_init = eu32_redmule_init, - .redmule_wait = eu32_redmule_wait, + .redmule_wait = eu_redmule_wait, .redmule_is_busy = eu32_redmule_is_busy, .redmule_is_done = eu32_redmule_is_done, .idma_init = eu32_idma_init, .idma_wait_direction = eu32_idma_wait_direction, - .idma_wait_a2o = eu32_idma_wait_a2o, - .idma_wait_o2a = eu32_idma_wait_o2a, + .idma_wait_a2o = eu_idma_wait_a2o, + .idma_wait_o2a = eu_idma_wait_o2a, .idma_is_done = eu32_idma_is_done, .idma_a2o_is_done = eu32_idma_a2o_is_done, .idma_o2a_is_done = eu32_idma_o2a_is_done, diff --git a/drivers/redmule16/include/redmule16.h b/drivers/redmule16/include/redmule16.h index 1c386007..fb0692cd 100644 --- a/drivers/redmule16/include/redmule16.h +++ b/drivers/redmule16/include/redmule16.h @@ -7,4 +7,99 @@ #pragma once -#include "redmule.h" \ No newline at end of file +#include +#include "redmule.h" +#include "utils/redmule_isa_utils.h" // redmule_mcnfig/marith, redmule_mm_* helpers + +// The enqueue/commit/start helpers live here as static inline (rather than +// out-of-line in redmule16.c) so they fold into their mglib call sites +// (mg_redmule.c), which are compiled -O2 -flto: redmule16.c is not built with +// LTO, so an out-of-line definition there could not be inlined into mglib. This +// mirrors the eventunit32.h pattern (eu32_redmule_wait etc.). + +/** + * Configure and launch an FP16 GEMM on the RedMulE accelerator. + * Computes: Y = X * W + Y where X is [M x N], W is [N x K], Y is [M x K]. + * + * The function issues the configuration and arithmetic commands to RedMulE + * via custom RISC-V instructions (REDMULE_MM=0) or memory-mapped HWPE + * registers (REDMULE_MM=1), then returns immediately. The caller must wait + * for completion (e.g. via eu_redmule_wait). + * + * This variant enqueues the job without triggering it. + * + * @param ctrl RedMulE controller handle (unused internally, reserved for API consistency). + * @param x OBI (L1) address of input matrix X [M x N]. + * @param w OBI (L1) address of weight matrix W [N x K]. + * @param y OBI (L1) address of bias/output matrix Y [M x K]. Accumulated in-place. + * @param m Number of rows of X and Y. + * @param n Number of columns of X / rows of W (inner dimension). + * @param k Number of columns of W and Y. + * + * @return 0 on successful dispatch. + */ +static inline __attribute__((always_inline)) int redmule16_gemm_enqueue(redmule_controller_t *ctrl, + uint32_t x, + uint32_t w, + uint32_t y, + uint16_t m, + uint16_t n, + uint16_t k) +{ +#if REDMULE_MM == 0 + redmule_mcnfig(k, m, n); // Set GEMM dimensions via custom RISC-V instruction + redmule_marith(y, w, x); // Launch GEMM with matrix addresses via custom RISC-V instruction +#else + redmule_mm_mcnfig(k, m, n); // Set GEMM dimensions via memory-mapped HWPE registers + redmule_mm_marith( + y, w, x); // Launch GEMM with matrix addresses via memory-mapped HWPE registers +#endif + + return 0; +} + +/** + * Commits execution of an enqueued job on the HW queue. + * + * @param ctrl RedMulE controller handle (unused internally, reserved for API consistency). + * + * @return 0 on successful dispatch. + */ +static inline __attribute__((always_inline)) int redmule16_gemm_commit(redmule_controller_t *ctrl) +{ +#if REDMULE_MM != 0 + redmule_mm_commit(); +#endif + return 0; +} + +/** + * Commits and starts execution of an enqueued job on the HW queue. + * + * @param ctrl RedMulE controller handle (unused internally, reserved for API consistency). + * + * @return 0 on successful dispatch. + */ +static inline __attribute__((always_inline)) int +redmule16_gemm_commit_start(redmule_controller_t *ctrl) +{ +#if REDMULE_MM != 0 + redmule_mm_commit_trigger(); +#endif + return 0; +} + +/** + * Starts execution of an enqueued set of jobs. + * + * @param ctrl RedMulE controller handle (unused internally, reserved for API consistency). + * + * @return 0 on successful dispatch. + */ +static inline __attribute__((always_inline)) int redmule16_gemm_start(redmule_controller_t *ctrl) +{ +#if REDMULE_MM != 0 + redmule_mm_trigger(); +#endif + return 0; +} diff --git a/drivers/redmule16/src/redmule16.c b/drivers/redmule16/src/redmule16.c index b0ae1399..8b6aa429 100644 --- a/drivers/redmule16/src/redmule16.c +++ b/drivers/redmule16/src/redmule16.c @@ -42,6 +42,19 @@ int32_t redmule16_acquire(redmule_controller_t *ctrl) #endif } +/** + * Writes the hardware COMMIT_TRIGGER register, which commits and triggers + * a hardware job. + */ +int32_t redmule16_trigger(redmule_controller_t *ctrl) +{ +#if REDMULE_MM == 1 + redmule_mm_trigger(); +#else + return 0; +#endif +} + /** * Configure and launch an FP16 GEMM on the RedMulE accelerator. * Computes: Y = X * W + Y where X is [M x N], W is [N x K], Y is [M x K]. @@ -77,10 +90,14 @@ int redmule16_gemm(redmule_controller_t *ctrl, redmule_mm_marith( y, w, x); // Launch GEMM with matrix addresses via memory-mapped HWPE registers #endif + redmule_mm_commit_trigger(); return 0; } +// redmule16_gemm_enqueue / _commit / _start are defined as static inline in +// redmule16.h so they fold into their mglib call sites (see the note there). + extern int redmule_init(redmule_controller_t *ctrl) __attribute__((alias("redmule16_init"), used, visibility("default"))); diff --git a/mglib/CMakeLists.txt b/mglib/CMakeLists.txt new file mode 100644 index 00000000..bcbe1c45 --- /dev/null +++ b/mglib/CMakeLists.txt @@ -0,0 +1,47 @@ +# Copyright 2024-2026 ETH Zurich, University of Bologna and Fondazione Chips-IT. +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +# +# Francesco Conti + +file(GLOB_RECURSE SOURCES + "src/*" +) + +add_library(mglib STATIC ${SOURCES}) + +# Optimize and enable LTO so the thin wrappers fold into their callers instead of +# each paying a full out-of-line stack frame. -ffat-lto-objects keeps libmglib.a +# usable by non-LTO consumers. (The toolchain sets no default -O, so without this +# mglib builds at -O0.) +target_compile_options(mglib PRIVATE -O2 -flto -ffat-lto-objects) + +# Keep the profiling hooks (stnl_*_f) alive in the inlined wait copies pulled in +# via eventunit32.h; these defines otherwise only reach the `runtime` target, +# which mglib does not link. +target_compile_options(mglib PRIVATE + -DPROFILE_CMP=${PROFILE_CMP} + -DPROFILE_CMI=${PROFILE_CMI} + -DPROFILE_CMO=${PROFILE_CMO} + -DPROFILE_SNC=${PROFILE_SNC} +) + +# The redmule16.h inline helpers (redmule16_gemm_enqueue/_commit/_start) pulled +# into mg_redmule.c select their code path with #if REDMULE_MM. That define is +# PUBLIC only on the `runtime` target, which mglib does not link, so re-pass it +# here (like the PROFILE_* defines above) - otherwise it would default to 0 and +# silently mismatch a redmule_mm=1 build. +target_compile_options(mglib PRIVATE -DREDMULE_MM=${REDMULE_MM}) + +target_include_directories(mglib + PUBLIC + "include" + "${CMAKE_SOURCE_DIR}/targets/${TARGET_PLATFORM}/include" + "${CMAKE_SOURCE_DIR}/drivers/eventunit32/include" + "${CMAKE_SOURCE_DIR}/drivers/redmule16/include" +) + +target_link_libraries(mglib + PUBLIC + "hal" +) \ No newline at end of file diff --git a/mglib/include/mg_event.h b/mglib/include/mg_event.h new file mode 100644 index 00000000..8d7a1578 --- /dev/null +++ b/mglib/include/mg_event.h @@ -0,0 +1,59 @@ +// Copyright 2026 ETH Zurich, University of Bologna and Fondazione Chips-IT. +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// Francesco Conti + +#pragma once + +#include + +#ifndef __ALWAYS_INLINE_ +#define __ALWAYS_INLINE_ __attribute__((always_inline)) +#endif + +/** Forward declaration so the callback signature can reference the event type. */ +typedef struct mg_event mg_event_t; + +/** + * @brief Callback invoked when an event is triggered. + */ +typedef void (*mg_event_callback_t)(mg_event_t *event); + +/** + * Generic event record: an identifier plus the callback to run for it. + */ +struct mg_event { + int32_t id; /**< Event identifier. */ + mg_event_callback_t callback; /**< Handler invoked when the event fires. */ +}; + +/** + * @brief Initialize an event with an id and callback. + */ +static inline __ALWAYS_INLINE_ void +mg_event_init(mg_event_t *event, int32_t id, mg_event_callback_t callback) +{ + event->id = id; + event->callback = callback; +} + +/** + * @brief Trigger an event, invoking its callback if set. + */ +static inline __ALWAYS_INLINE_ void mg_event_trigger(mg_event_t *event) +{ + if (event->callback) { + event->callback(event); + } +} + +/** + * Circular sequence comparison: true if `a` has occurred at or after `b` on + * an 8-bit wrapping counter (e.g. a hardware-issued/completed job or transfer + * counter). Only valid while the two are never more than 127 apart. + */ +static inline int mg_seq_ge(uint8_t a, uint8_t b) +{ + return (int8_t)(a - b) >= 0; +} diff --git a/mglib/include/mg_idma.h b/mglib/include/mg_idma.h new file mode 100644 index 00000000..928ff901 --- /dev/null +++ b/mglib/include/mg_idma.h @@ -0,0 +1,102 @@ +// Copyright 2026 ETH Zurich, University of Bologna and Fondazione Chips-IT. +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// Francesco Conti + +#pragma once + +#include +#include "eventunit32.h" +#include "idma.h" +#include "mg_event.h" + +/** + * Issue an asynchronous 1D iDMA transfer and stamp `event` with the id needed + * to later wait for its completion via mg_idma_wait(). + * + * WORKAROUND: the current iDMA HW holds only one in-flight transfer per + * direction, so this may block (per `mode`, draining `eu` completion pulses) + * until a previously issued same-direction transfer has drained before it can + * issue - a software-emulated depth-1 job queue. See MG_IDMA_HW_QUEUE_DEPTH in + * mg_idma.c. + */ +extern void mg_idma_memcpy_1d(idma_controller_t *idma, + eu_controller_t *eu, + eu_wait_mode_t mode, + uint8_t dir, + uint32_t axi_addr, + uint32_t obi_addr, + uint32_t len, + mg_event_t *event, + mg_event_callback_t callback); + +/** + * Issue an asynchronous 2D iDMA transfer and stamp `event` with the id needed + * to later wait for its completion via mg_idma_wait(). + * + * WORKAROUND: as for mg_idma_memcpy_1d(), this may block (per `mode`, draining + * `eu` completion pulses) until a previously issued same-direction transfer has + * drained before it can issue - a software-emulated depth-1 job queue. + */ +extern void mg_idma_memcpy_2d(idma_controller_t *idma, + eu_controller_t *eu, + eu_wait_mode_t mode, + uint8_t dir, + uint32_t axi_addr, + uint32_t obi_addr, + uint32_t len, + uint32_t std, + uint32_t reps, + mg_event_t *event, + mg_event_callback_t callback); + +/** + * Per-direction completion counter (index 0 = A2O/L2->L1, 1 = O2A/L1->L2). + * Defined in mg_idma.c and advanced from both the issue path (mg_idma_issue) + * and mg_idma_wait() below; shared so both observe a single instance. + */ +extern uint8_t mg_idma_completed[2]; + +/** + * Block (per `mode`) until `event` (as produced by mg_idma_memcpy_1d/2d for + * direction `dir`) has completed, then run its callback if set. + * + * iDMA transfers on the same direction complete strictly in issue order, so + * this consumes hardware completion pulses one at a time - advancing a + * per-direction completion counter - until that counter has caught up with + * `event`'s id. That may happen immediately, if the transfer already + * completed while waiting on a later event, or only after spinning on new + * pulses. + * + * Defined here as a static inline (rather than out-of-line in mg_idma.c) so it + * folds into its call sites under -O/-flto. + */ +static inline __ALWAYS_INLINE_ void +mg_idma_wait(eu_controller_t *eu, uint8_t dir, eu_wait_mode_t mode, mg_event_t *event) +{ + uint8_t idx = dir ? 1 : 0; + uint8_t target = (uint8_t)(event->id + 1); + + // the event may already be done - e.g. its completion pulse was + // consumed while waiting on a later id - in which case we must not + // wait on the hardware at all. + while (!mg_seq_ge(mg_idma_completed[idx], target)) { + // dnot yet the right one: spin back into the hardware wait. + uint32_t done; + if (dir) { + done = eu32_idma_wait_o2a(eu, mode); + } else { + done = eu32_idma_wait_a2o(eu, mode); + } + if (done) { + // update the completion counter whenever a pulse was seen: it + // always retires exactly one FIFO-ordered transfer, whether or + // not it is the one we are waiting for. + mg_idma_completed[idx]++; + } + } + + // our event is the one that just completed (or had already completed). + mg_event_trigger(event); +} diff --git a/mglib/include/mg_redmule.h b/mglib/include/mg_redmule.h new file mode 100644 index 00000000..c5c33462 --- /dev/null +++ b/mglib/include/mg_redmule.h @@ -0,0 +1,91 @@ +// Copyright 2026 ETH Zurich, University of Bologna and Fondazione Chips-IT. +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// Francesco Conti + +#pragma once + +#include +#include "eventunit32.h" +#include "redmule.h" +#include "mg_event.h" + +/** + * Issue an asynchronous RedMulE GEMM job and stamp `event` with the id needed + * to later wait for its completion via mg_redmule_wait(). + * + * The event id is the real hardware-issued job id, obtained by reading the + * ACQUIRE register (redmule_api.acquire()). If the hardware's job queue + * (depth 2) is already full, this call blocks - draining completion pulses + * through `eu`/`mode`, exactly like mg_redmule_wait() does - until a slot + * frees and a fresh id can be acquired. + */ +extern void mg_redmule_gemm(redmule_controller_t *ctrl, + eu_controller_t *eu, + eu_wait_mode_t mode, + uint32_t x, + uint32_t w, + uint32_t y, + uint16_t m, + uint16_t n, + uint16_t k, + mg_event_t *event, + mg_event_callback_t callback); +extern void mg_redmule_gemm_enqueue(redmule_controller_t *ctrl, + eu_controller_t *eu, + eu_wait_mode_t mode, + uint32_t x, + uint32_t w, + uint32_t y, + uint16_t m, + uint16_t n, + uint16_t k, + mg_event_t *event, + mg_event_callback_t callback); +extern void mg_redmule_gemm_commit_start(redmule_controller_t *ctrl); +extern void mg_redmule_gemm_start(redmule_controller_t *ctrl); +extern void mg_redmule_gemm_commit(redmule_controller_t *ctrl); + +/** + * Completion counter. Defined in mg_redmule.c and advanced from both the + * acquire/backpressure path (mg_redmule_gemm/enqueue) and mg_redmule_wait() + * below; shared so both observe a single instance. Only the low 8 bits are + * significant (see mg_seq_ge()). + */ +extern uint8_t mg_redmule_completed; + +/** + * Block (per `mode`) until `event` (as produced by mg_redmule_gemm) has + * completed, then run its callback if set. + * + * RedMulE jobs complete strictly in issue order, so this consumes hardware + * completion pulses one at a time - advancing a completion counter - until + * that counter has caught up with `event`'s id. That may happen immediately, + * if the job already completed while waiting on a later event, or only after + * spinning on new pulses. + * + * Defined here as a static inline (rather than out-of-line in mg_redmule.c) so + * it folds into its call sites under -O/-flto. + */ +static inline __ALWAYS_INLINE_ void +mg_redmule_wait(eu_controller_t *eu, eu_wait_mode_t mode, mg_event_t *event) +{ + uint8_t target = (uint8_t)(event->id + 1); + + // the event may already be done - e.g. its completion pulse was consumed + // while waiting on a later id - in which case we must not wait on the + // hardware at all. + while (!mg_seq_ge(mg_redmule_completed, target)) { + // not yet the right one: spin back into the hardware wait. + if (eu32_redmule_wait(eu, mode)) { + // update the completion counter whenever a pulse was seen: it + // always retires exactly one FIFO-ordered job, whether or not it + // is the one we are waiting for. + mg_redmule_completed++; + } + } + + // our event is the one that just completed (or had already completed). + mg_event_trigger(event); +} diff --git a/mglib/src/mg_idma.c b/mglib/src/mg_idma.c new file mode 100644 index 00000000..1d27dd7d --- /dev/null +++ b/mglib/src/mg_idma.c @@ -0,0 +1,94 @@ +// Copyright 2026 ETH Zurich, University of Bologna and Fondazione Chips-IT. +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// Francesco Conti + +#include +#include "mg_idma.h" + +/** + * Per-direction issue/completion counters (index 0 = A2O/L2->L1, 1 = O2A/L1->L2). + * The number of iDMA transfers ever in flight at once is always far below 256, so + * wrapping these counters is safe. + * + * These are per-tile completion bookkeeping, so they must live in per-tile-aliased + * memory rather than the shared-L2 .bss (where every tile would collide on one + * copy). The .tile_bss section is private per tile and zeroed by every hart in + * crt0, so no initializer is given here. + */ +static uint8_t mg_idma_issued[2] __attribute__((section(".tile_bss"))); +// External linkage (declared in mg_idma.h): shared with the now-inlined +// mg_idma_wait() so both the issue path (here) and the wait path observe a +// single completion counter. Only the issue path touches mg_idma_issued, so it +// stays file-static. +uint8_t mg_idma_completed[2] __attribute__((section(".tile_bss"))); + +// WORKAROUND: the current iDMA HW (at least in the GVSOC model) has no job +// queue and holds only one in-flight transfer per direction; issuing a new +// transfer while the engine is busy raises +// "read IDMA_NEXT_ID ... when not in IDLE state". We emulate a depth-1 +// per-direction job queue in software (see mg_idma_issue()) so callers can +// pipeline issues without manually interleaving waits. Raise this once the +// HW/model gains real job queueing. +#define MG_IDMA_HW_QUEUE_DEPTH 1 + +static inline __ALWAYS_INLINE_ void mg_idma_issue(eu_controller_t *eu, + eu_wait_mode_t mode, + uint8_t dir, + mg_event_t *event, + mg_event_callback_t callback) +{ + uint8_t idx = dir ? 1 : 0; + // WORKAROUND: backpressure - block until this direction has a free slot in + // the (software-emulated) HW job queue before issuing. Draining a + // completion pulse here shares mg_idma_completed[idx] with mg_idma_wait(); + // that is safe because same-direction transfers retire strictly FIFO. + while ((uint8_t)(mg_idma_issued[idx] - mg_idma_completed[idx]) >= MG_IDMA_HW_QUEUE_DEPTH) { + uint32_t done = dir ? eu32_idma_wait_o2a(eu, mode) : eu32_idma_wait_a2o(eu, mode); + if (done) { + mg_idma_completed[idx]++; + } + } + mg_event_init(event, (int32_t)mg_idma_issued[idx], callback); + mg_idma_issued[idx]++; +} + +void mg_idma_memcpy_1d(idma_controller_t *idma, + eu_controller_t *eu, + eu_wait_mode_t mode, + uint8_t dir, + uint32_t axi_addr, + uint32_t obi_addr, + uint32_t len, + mg_event_t *event, + mg_event_callback_t callback) +{ + // May block until a prior same-direction transfer drains (see + // mg_idma_issue() and the MG_IDMA_HW_QUEUE_DEPTH workaround). + mg_idma_issue(eu, mode, dir, event, callback); + // Triggers the transfer. + idma_memcpy_1d(idma, dir, axi_addr, obi_addr, len); +} + +void mg_idma_memcpy_2d(idma_controller_t *idma, + eu_controller_t *eu, + eu_wait_mode_t mode, + uint8_t dir, + uint32_t axi_addr, + uint32_t obi_addr, + uint32_t len, + uint32_t std, + uint32_t reps, + mg_event_t *event, + mg_event_callback_t callback) +{ + // May block until a prior same-direction transfer drains (see + // mg_idma_issue() and the MG_IDMA_HW_QUEUE_DEPTH workaround). + mg_idma_issue(eu, mode, dir, event, callback); + idma_memcpy_2d(idma, dir, axi_addr, obi_addr, len, std, reps); +} + +// mg_idma_wait() is defined as a static inline in mg_idma.h so it folds into +// its call sites (removing the call/return and the one-time cold I-cache miss, +// and letting constant-propagation drop the callback tail where it is NULL). diff --git a/mglib/src/mg_redmule.c b/mglib/src/mg_redmule.c new file mode 100644 index 00000000..ceb05f3d --- /dev/null +++ b/mglib/src/mg_redmule.c @@ -0,0 +1,95 @@ +// Copyright 2026 ETH Zurich, University of Bologna and Fondazione Chips-IT. +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// Francesco Conti + +#include +#include "mg_redmule.h" +#include "redmule16.h" // static inline redmule16_gemm_enqueue/_commit/_start + +/** + * Completion counter. Only the low 8 bits are significant (see mg_seq_ge() + * in mg_event.h): the number of RedMulE jobs ever in flight at once is + * always far below 256, so wrapping is safe. + * + * Advanced from two places: mg_redmule_gemm()'s backpressure spin (below) + * and mg_redmule_wait(). That is safe because RedMulE jobs retire strictly + * in FIFO order regardless of which call site happens to observe a given + * completion pulse. + * + * Per-tile completion bookkeeping, so it lives in per-tile-aliased .tile_bss + * (private per tile, zeroed by every hart in crt0) rather than the shared-L2 + * .bss where all tiles would collide on one copy - hence no initializer here. + */ +// External linkage (declared in mg_redmule.h): shared with the now-inlined +// mg_redmule_wait() so both the acquire/backpressure path (here) and the wait +// path observe a single completion counter. +uint8_t mg_redmule_completed __attribute__((section(".tile_bss"))); + +void mg_redmule_gemm(redmule_controller_t *ctrl, + eu_controller_t *eu, + eu_wait_mode_t mode, + uint32_t x, + uint32_t w, + uint32_t y, + uint16_t m, + uint16_t n, + uint16_t k, + mg_event_t *event, + mg_event_callback_t callback) +{ + int32_t id; + while ((id = redmule_acquire(ctrl)) < 0) { + // Hardware queue (depth 2) is full: drain one completion pulse to + // free a slot before retrying the acquire. + if (eu32_redmule_wait(eu, mode)) { + mg_redmule_completed++; + } + } + mg_event_init(event, id, callback); + redmule_gemm(ctrl, x, w, y, m, n, k); +} + +void mg_redmule_gemm_enqueue(redmule_controller_t *ctrl, + eu_controller_t *eu, + eu_wait_mode_t mode, + uint32_t x, + uint32_t w, + uint32_t y, + uint16_t m, + uint16_t n, + uint16_t k, + mg_event_t *event, + mg_event_callback_t callback) +{ + int32_t id; + while ((id = redmule_acquire(ctrl)) < 0) { + // Hardware queue (depth 2) is full: drain one completion pulse to + // free a slot before retrying the acquire. + if (eu32_redmule_wait(eu, mode)) { + mg_redmule_completed++; + } + } + mg_event_init(event, id, callback); + redmule16_gemm_enqueue(ctrl, x, w, y, m, n, k); +} + +void mg_redmule_gemm_commit_start(redmule_controller_t *ctrl) +{ + redmule16_gemm_commit_start(ctrl); +} + +void mg_redmule_gemm_commit(redmule_controller_t *ctrl) +{ + redmule16_gemm_commit(ctrl); +} + +void mg_redmule_gemm_start(redmule_controller_t *ctrl) +{ + redmule16_gemm_start(ctrl); +} + +// mg_redmule_wait() is defined as a static inline in mg_redmule.h so it folds +// into its call sites (removing the call/return and the one-time cold I-cache +// miss, and letting constant-propagation drop the callback tail where NULL). diff --git a/pyproject.toml b/pyproject.toml index 2634c980..b68e941b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -29,6 +29,7 @@ nb = [ ] gemm = [ "torch", + "tqdm" ] [tool.setuptools.packages.find] @@ -40,4 +41,4 @@ torch = { index = "pytorch-cpu" } [[tool.uv.index]] name = "pytorch-cpu" url = "https://download.pytorch.org/whl/cpu" -explicit = true \ No newline at end of file +explicit = true diff --git a/scripts/gvsoc2perfetto-rs/.gitignore b/scripts/gvsoc2perfetto-rs/.gitignore new file mode 100644 index 00000000..ea8c4bf7 --- /dev/null +++ b/scripts/gvsoc2perfetto-rs/.gitignore @@ -0,0 +1 @@ +/target diff --git a/targets/magia_v2/include/utils/redmule_isa_utils.h b/targets/magia_v2/include/utils/redmule_isa_utils.h index 02d7d897..5c99c47c 100644 --- a/targets/magia_v2/include/utils/redmule_isa_utils.h +++ b/targets/magia_v2/include/utils/redmule_isa_utils.h @@ -15,7 +15,7 @@ * SPDX-License-Identifier: Apache-2.0 * * Authors: Victor Isachi - * + * * MAGIA RedMulE ISA Utils */ @@ -26,25 +26,26 @@ #include "regs/tile_ctrl.h" #include "performance_utils.h" -#define HWPE_WRITE(value, offset) *(volatile uint32_t*)(REDMULE_BASE + offset) = value -#define HWPE_READ(offset) *(volatile uint32_t*)(REDMULE_BASE + offset) +#define HWPE_WRITE(value, offset) *(volatile uint32_t *)(REDMULE_BASE + offset) = value +#define HWPE_READ(offset) *(volatile uint32_t *)(REDMULE_BASE + offset) -#define redmule_wait() __asm__ __volatile__("wfi" ::: "memory") +#define redmule_wait() __asm__ __volatile__("wfi" ::: "memory") /* mcnfig instruction */ - // asm volatile( - // ".word (0x0 << 25) | \ /* Empty */ - // (0b00110 << 20) | \ /* Rs2 - t1 */ - // (0b00101 << 15) | \ /* Rs1 - t0 */ - // (0x00 << 7) | \ /* Empty */ - // (0b0001011 << 0) \n"); /* OpCode */ -inline void redmule_mcnfig(volatile uint16_t k_size, volatile uint16_t m_size, volatile uint16_t n_size){ - uint32_t cfg_reg0 = (k_size << 16) | (m_size << 0); - uint32_t cfg_reg1 = n_size << 0; - asm volatile("addi t0, %0, 0" ::"r"(cfg_reg0)); - asm volatile("addi t1, %0, 0" ::"r"(cfg_reg1)); - asm volatile( - ".word (0x0 << 25) | \ +// asm volatile( +// ".word (0x0 << 25) | \ /* Empty */ +// (0b00110 << 20) | \ /* Rs2 - t1 */ +// (0b00101 << 15) | \ /* Rs1 - t0 */ +// (0x00 << 7) | \ /* Empty */ +// (0b0001011 << 0) \n"); /* OpCode */ +inline void +redmule_mcnfig(volatile uint16_t k_size, volatile uint16_t m_size, volatile uint16_t n_size) +{ + uint32_t cfg_reg0 = (k_size << 16) | (m_size << 0); + uint32_t cfg_reg1 = n_size << 0; + asm volatile("addi t0, %0, 0" ::"r"(cfg_reg0)); + asm volatile("addi t1, %0, 0" ::"r"(cfg_reg1)); + asm volatile(".word (0x0 << 25) | \ (0b00110 << 20) | \ (0b00101 << 15) | \ (0x00 << 7) | \ @@ -52,25 +53,26 @@ inline void redmule_mcnfig(volatile uint16_t k_size, volatile uint16_t m_size, v } /* marith instruction */ - // asm volatile( - // ".word (0b00111 << 27) | \ /* Rs3 - t2 */ - // (0b00 << 25) | \ /* Empty */ - // (0b00110 << 20) | \ /* Rs2 - t1 */ - // (0b00101 << 15) | \ /* Rs1 - t0 */ - // (0b0 << 14) | \ /* Custom format enable/disable */ - // (0b0 << 13) | \ /* Widening enable/disable */ - // (0b001 << 10) | \ /* Operation selection */ - // (0b001 << 7) | \ /* Data format */ - // (0b0101011 << 0) \n"); /* OpCode */ -inline void redmule_marith(volatile uint32_t y_base, volatile uint32_t w_base, volatile uint32_t x_base){ - asm volatile("addi t2, %0, 0" ::"r"(y_base)); - asm volatile("addi t1, %0, 0" ::"r"(w_base)); - asm volatile("addi t0, %0, 0" ::"r"(x_base)); - #if PROFILE_CMP == 1 - stnl_cmp_s(); - #endif - asm volatile( - ".word (0b00111 << 27) | \ +// asm volatile( +// ".word (0b00111 << 27) | \ /* Rs3 - t2 */ +// (0b00 << 25) | \ /* Empty */ +// (0b00110 << 20) | \ /* Rs2 - t1 */ +// (0b00101 << 15) | \ /* Rs1 - t0 */ +// (0b0 << 14) | \ /* Custom format enable/disable */ +// (0b0 << 13) | \ /* Widening enable/disable */ +// (0b001 << 10) | \ /* Operation selection */ +// (0b001 << 7) | \ /* Data format */ +// (0b0101011 << 0) \n"); /* OpCode */ +inline void +redmule_marith(volatile uint32_t y_base, volatile uint32_t w_base, volatile uint32_t x_base) +{ + asm volatile("addi t2, %0, 0" ::"r"(y_base)); + asm volatile("addi t1, %0, 0" ::"r"(w_base)); + asm volatile("addi t0, %0, 0" ::"r"(x_base)); +#if PROFILE_CMP == 1 + stnl_cmp_s(); +#endif + asm volatile(".word (0b00111 << 27) | \ (0b00 << 25) | \ (0b00110 << 20) | \ (0b00101 << 15) | \ @@ -79,47 +81,65 @@ inline void redmule_marith(volatile uint32_t y_base, volatile uint32_t w_base, v (0b001 << 10) | \ (0b001 << 7) | \ (0b0101011 << 0) \n"); - #if STALLING == 1 - volatile uint32_t status; - do { - status = *(volatile uint32_t *)(REDMULE_BASE + REDMULE_STATUS); - } while (status & REDMULE_STATUS_BUSY_MASK); - #if PROFILE_CMP == 1 - stnl_cmp_f(); - #endif - #endif +#if STALLING == 1 + volatile uint32_t status; + do { + status = *(volatile uint32_t *)(REDMULE_BASE + REDMULE_STATUS); + } while (status & REDMULE_STATUS_BUSY_MASK); +#if PROFILE_CMP == 1 + stnl_cmp_f(); +#endif +#endif +} + +inline int +redmule_mm_mcnfig(volatile uint16_t k_size, volatile uint16_t m_size, volatile uint16_t n_size) +{ + volatile uint32_t mcfg_reg0 = (k_size << 16) | (m_size << 0); + volatile uint32_t mcfg_reg1 = (0x1 << 25) | (0x1 << 23) | (0x1 << 20) | (n_size << 0); + volatile uint32_t mcfg_reg2 = 0; + HWPE_WRITE(mcfg_reg0, REDMULE_REG_OFFS + REDMULE_MCFG0_PTR); + HWPE_WRITE(mcfg_reg1, REDMULE_REG_OFFS + REDMULE_MCFG1_PTR); + HWPE_WRITE(mcfg_reg2, REDMULE_REG_OFFS + REDMULE_MCFG2_PTR); + return 0; +} + +inline int +redmule_mm_marith(volatile uint32_t y_base, volatile uint32_t w_base, volatile uint32_t x_base) +{ + volatile uint32_t arith_reg = (0b001 << 10) | (0b001 << 7); + HWPE_WRITE(x_base, REDMULE_REG_OFFS + REDMULE_REG_X_PTR); + HWPE_WRITE(w_base, REDMULE_REG_OFFS + REDMULE_REG_W_PTR); + HWPE_WRITE(y_base, REDMULE_REG_OFFS + REDMULE_REG_Z_PTR); + HWPE_WRITE(arith_reg, REDMULE_REG_OFFS + REDMULE_ARITH_PTR); +#if PROFILE_CMP == 1 + stnl_cmp_s(); +#endif +#if STALLING == 1 + volatile uint32_t status; + do { + status = *(volatile uint32_t *)(REDMULE_BASE + REDMULE_STATUS); + } while (status & REDMULE_STATUS_BUSY_MASK); +#if PROFILE_CMP == 1 + stnl_cmp_f(); +#endif +#endif + return 0; +} + +inline int redmule_mm_commit_trigger() +{ + HWPE_WRITE(0, REDMULE_TRIGGER); } -inline int redmule_mm_mcnfig(volatile uint16_t k_size, volatile uint16_t m_size, volatile uint16_t n_size){ - volatile uint32_t mcfg_reg0 = (k_size << 16) | (m_size << 0); - volatile uint32_t mcfg_reg1 = (0x1 << 25) | (0x1 << 23) | (0x1 << 20) | (n_size << 0); - volatile uint32_t mcfg_reg2 = 0; - HWPE_WRITE(mcfg_reg0, REDMULE_REG_OFFS + REDMULE_MCFG0_PTR); - HWPE_WRITE(mcfg_reg1, REDMULE_REG_OFFS + REDMULE_MCFG1_PTR); - HWPE_WRITE(mcfg_reg2, REDMULE_REG_OFFS + REDMULE_MCFG2_PTR); - return 0; +inline int redmule_mm_commit() +{ + HWPE_WRITE(1, REDMULE_TRIGGER); } -inline int redmule_mm_marith(volatile uint32_t y_base, volatile uint32_t w_base, volatile uint32_t x_base){ - volatile uint32_t arith_reg = (0b001 << 10) | (0b001 << 7); - HWPE_WRITE(x_base, REDMULE_REG_OFFS + REDMULE_REG_X_PTR); - HWPE_WRITE(w_base, REDMULE_REG_OFFS + REDMULE_REG_W_PTR); - HWPE_WRITE(y_base, REDMULE_REG_OFFS + REDMULE_REG_Z_PTR); - HWPE_WRITE(arith_reg, REDMULE_REG_OFFS + REDMULE_ARITH_PTR); - #if PROFILE_CMP == 1 - stnl_cmp_s(); - #endif - HWPE_WRITE(0, REDMULE_TRIGGER); - #if STALLING == 1 - volatile uint32_t status; - do { - status = *(volatile uint32_t *)(REDMULE_BASE + REDMULE_STATUS); - } while (status & REDMULE_STATUS_BUSY_MASK); - #if PROFILE_CMP == 1 - stnl_cmp_f(); - #endif - #endif - return 0; +inline int redmule_mm_trigger() +{ + HWPE_WRITE(2, REDMULE_TRIGGER); } #endif /*REDMULE_ISA_UTILS_H*/ \ No newline at end of file diff --git a/targets/magia_v2/link.ld b/targets/magia_v2/link.ld index ee5977ad..cf3eb99e 100644 --- a/targets/magia_v2/link.ld +++ b/targets/magia_v2/link.ld @@ -18,6 +18,12 @@ SEARCH_DIR(.) __DYNAMIC = 0; +/* Pin the ELF entry point to _start. Without this, ld defaults the entry to the + * first byte of .text, which the loader uses as the core boot address. Under -flto + * the link may place another function (e.g. to_x) first, so the entry would boot + * into arbitrary code with an uninitialized register file instead of crt0. */ +ENTRY(_start) + MEMORY { instrram : ORIGIN = 0xcc000000, LENGTH = 0x8000 @@ -150,4 +156,17 @@ SECTIONS _stack = . ; } > stack :NONE + /* Per-tile-aliased scratch (private to each tile, unlike the shared-L2 .bss). + * Placed above the stack top so the downward-growing stack never reaches it. + * Zeroed by every hart in crt0 (see _tile_bss_start/_tile_bss_end). */ + _tile_bss_size = 0x400; /* 1 KiB per-tile scratch */ + .tile_bss (NOLOAD): { + . = ALIGN(4); + _tile_bss_start = . ; + *(.tile_bss) + *(.tile_bss.*) + . = _tile_bss_start + _tile_bss_size ; /* fixed 1 KiB reservation */ + _tile_bss_end = . ; + } > stack :NONE + } diff --git a/targets/magia_v2/src/crt0.S b/targets/magia_v2/src/crt0.S index f3f6c842..4bef4e6e 100644 --- a/targets/magia_v2/src/crt0.S +++ b/targets/magia_v2/src/crt0.S @@ -81,6 +81,17 @@ _start: skip_bss_clear: + # clear the per-tile .tile_bss on every hart (per-tile aliased memory, so + # each control core must zero its own copy - unlike the shared-L2 .bss above) + la t0, _tile_bss_start + la t1, _tile_bss_end + bgeu t0, t1, 3f +2: + sw zero, 0(t0) + addi t0, t0, 4 + bltu t0, t1, 2b +3: + /* Stack initialization */ la x2, stack diff --git a/tests/magia/mesh/CMakeLists.txt b/tests/magia/mesh/CMakeLists.txt index e6d4db28..50aec13a 100644 --- a/tests/magia/mesh/CMakeLists.txt +++ b/tests/magia/mesh/CMakeLists.txt @@ -20,6 +20,7 @@ endif() add_subdirectory(cemm_global) add_subdirectory(mm_is_2) add_subdirectory(mm_os_2) +add_subdirectory(mm_os_mglib) add_subdirectory(mm_ws_2) # add_subdirectory(brah) add_subdirectory(fsync_lr) diff --git a/tests/magia/mesh/mm_generator/gemm.py b/tests/magia/mesh/mm_generator/gemm.py new file mode 100644 index 00000000..fc2c3386 --- /dev/null +++ b/tests/magia/mesh/mm_generator/gemm.py @@ -0,0 +1,188 @@ +# Copyright 2023 ETH Zurich and University of Bologna. +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +# +# Yvan Tortorella +# + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.optim as optim +import argparse +import os +from tqdm import tqdm + +# COMPUTE: +# Z[m_size, k_size] = ( X[m_size, n_size] max W[n_size, k_size] ) + Y[m_size, k_size] + +#Visualize data with more precision +torch.set_printoptions(precision=10, sci_mode=False) + +parser = argparse.ArgumentParser("mm Operation Test") +parser.add_argument( '--m_size', type=int, default=3 ) +parser.add_argument( '--n_size', type=int, default=3 ) +parser.add_argument( '--k_size', type=int, default=3 ) +parser.add_argument( '--inc_dir', type=str, default='include') +args = parser.parse_args() + +# Network parameters +m_size = args.m_size +n_size = args.n_size +k_size = args.k_size + +# We want to perform a GEMM, of the kind Z = Y + X*W +# Test Matrices +X = torch.rand(m_size, n_size) +W = torch.rand(n_size, k_size) +Y = torch.rand(m_size, k_size) +Z = torch.rand(m_size, k_size) + +print("\nInput Data: ") +print("\nX is: ", X, X.shape, X.dtype) + +print("\nW is: ", W, W.shape, W.dtype) + +print("\nY is: ", Y, Y.shape, Y.dtype) + +print("\nComputing bit-true matrix multiplication..") + +import numpy as np + +def bittrue_fma(a, x, b): + # Simulate FP16 FMA with intermediate rounding + a_fp32 = np.float16(a).astype(np.float64) + x_fp32 = np.float16(x).astype(np.float64) + b_fp32 = np.float16(b).astype(np.float64) + result = a_fp32 * x_fp32 + b_fp32 + return np.float16(result).astype(np.float64) + +def matrix_multiply_with_bittrue_fma(X, W, Y): + M, K = X.shape + K2, N = W.shape + assert K == K2, "Inner dimensions must match" + + Z = np.zeros((M, N), dtype=np.float64) + + for m in tqdm(range(M)): + for n in range(N): + acc = Y[m, n].astype(np.float64) # Start with Y as accumulator + for k in range(K): + acc = bittrue_fma(X[m, k], W[k, n], acc) + Z[m, n] = acc + Z = Z.astype(np.float16) + + return Z +X_np = X.cpu().numpy() +W_np = W.cpu().numpy() +Y_np = Y.cpu().numpy() +Z = matrix_multiply_with_bittrue_fma(X_np, W_np, Y_np) +Z = torch.from_numpy(Z).to(dtype=torch.float16) + +print("\nZ is: ", Z, Z.shape, Z.dtype) + +print("\n\n") + +in_rows = str(m_size) +in_cols = str(n_size) +out_cols = str(k_size) +x_dim = str(m_size*n_size) +w_dim = str(n_size*k_size) +y_dim = str(m_size*k_size) +z_dim = str(m_size*k_size) +out_int = str(int(m_size*k_size/2)) + +# ------------------------------------------------------------------------------------# +# Header file generation # +# ------------------------------------------------------------------------------------# + +# Create include directory if it doesn't exist +inc_path = args.inc_dir +if not os.path.exists(inc_path): + os.makedirs(inc_path) + +# Generate single test.h file +f = open(os.path.join(inc_path, 'test.h'), "w") + +# Write header guard and comments +f.write('// Copyright 2026 ETH Zurich, University of Bologna and Fondazione Chips-IT.\n') +f.write('// Licensed under the Apache License, Version 2.0, see LICENSE for details.\n') +f.write('// SPDX-License-Identifier: Apache-2.0\n') +f.write('// Generated by gen_golden.py (M='+in_rows+', N='+in_cols+', P='+out_cols+', seed=42)\n') +f.write('//\n') +f.write('// GEMM with bias: Z['+in_rows+'x'+out_cols+'] = X['+in_rows+'x'+in_cols+'] @ W['+in_cols+'x'+out_cols+'] + Y['+in_rows+'x'+out_cols+']\n') +f.write('\n') +f.write('#ifndef _TEST_MM_OS_INCLUDE_GUARD_\n') +f.write('#define _TEST_MM_OS_INCLUDE_GUARD_\n') +f.write('\n') + +# Write size defines +f.write('#define M_SIZE ('+in_rows+')\n') +f.write('#define N_SIZE ('+in_cols+')\n') +f.write('#define K_SIZE ('+out_cols+')\n') +f.write('\n') + +# Write x_inp array +f.write('uint16_t x_inp [M_SIZE * N_SIZE] = {\n') +for i in range(m_size): + for j in range(n_size): + x_bin = bin(np.float16(X[i][j]).view('H'))[2:].zfill(16) + x_hex = hex(int(x_bin, 2))[2:] + if (i == m_size - 1 and j == n_size - 1): + f.write('0x'+x_hex) + else: + f.write('0x'+x_hex+', ') + if (j == n_size - 1): + f.write('\n') +f.write('};\n') +f.write('\n') + +# Write w_inp array +f.write('uint16_t w_inp [N_SIZE * K_SIZE] = {\n') +for i in range(n_size): + for j in range(k_size): + w_bin = bin(np.float16(W[i][j]).view('H'))[2:].zfill(16) + w_hex = hex(int(w_bin, 2))[2:] + if (i == n_size - 1 and j == k_size - 1): + f.write('0x'+w_hex) + else: + f.write('0x'+w_hex+', ') + if (j == k_size - 1): + f.write('\n') +f.write('};\n') +f.write('\n') + +# Write y_inp array +f.write('uint16_t y_inp [M_SIZE * K_SIZE] = {\n') +for i in range(m_size): + for j in range(k_size): + y_bin = bin(np.float16(Y[i][j]).view('H'))[2:].zfill(16) + y_hex = hex(int(y_bin, 2))[2:] + if (i == m_size - 1 and j == k_size - 1): + f.write('0x'+y_hex) + else: + f.write('0x'+y_hex+', ') + if (j == k_size - 1): + f.write('\n') +f.write('};\n') +f.write('\n') + +# Write z_out array +f.write('uint16_t z_out [M_SIZE * K_SIZE] = {\n') +for i in range(m_size): + for j in range(k_size): + z_bin = bin(np.float16(Z[i][j]).view('H'))[2:].zfill(16) + z_hex = hex(int(z_bin, 2))[2:] + if (i == m_size - 1 and j == k_size - 1): + f.write('0x'+z_hex) + else: + f.write('0x'+z_hex+', ') + if (j == k_size - 1): + f.write('\n') +f.write('};\n') +f.write('\n') + +# Write closing header guard +f.write('#endif //_TEST_GEMM_INCLUDE_GUARD_\n') +f.close() diff --git a/tests/magia/mesh/mm_os_2/src/test.c b/tests/magia/mesh/mm_os_2/src/test.c index 41e08a20..89a852cb 100644 --- a/tests/magia/mesh/mm_os_2/src/test.c +++ b/tests/magia/mesh/mm_os_2/src/test.c @@ -98,7 +98,7 @@ int main(void) * Weight data-tile: (t_size x tile_w) * data_dim * Output data-tile: ((tile_h x tile_w) * data_dim) */ - uint8_t timeslots = 2; + uint8_t timeslots = 8; uint8_t t_size = N_SIZE / timeslots; /** diff --git a/tests/magia/mesh/mm_os_mglib/CMakeLists.txt b/tests/magia/mesh/mm_os_mglib/CMakeLists.txt new file mode 100644 index 00000000..e4ecce54 --- /dev/null +++ b/tests/magia/mesh/mm_os_mglib/CMakeLists.txt @@ -0,0 +1,34 @@ +# Copyright 2024-2026 ETH Zurich, University of Bologna and Fondazione Chips-IT. +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +# +# Moritz Scherer +# Philip Wiese +# Alberto Dequino + +set(TEST_NAME test_mm_os_mglib) + +file(GLOB_RECURSE TEST_SRCS + "src/*.c" +) + +add_executable(${TEST_NAME} ${TEST_SRCS}) +target_include_directories(${TEST_NAME} PUBLIC include) + +target_compile_options(${TEST_NAME} + PRIVATE + -O3 + -flto +) +# LTO at link folds the mglib wrappers into this test's call sites. +# --allow-multiple-definition: io.c's libc stubs (memcpy/memset/...) are compiled +# both here and into libeu_lib.a; identical source, so taking the first is safe. +# (Pre-existing duplication that LTO's symbol resolver exposes; mirrors the Spatz +# link config in cmake/spatz_config.cmake.) +target_link_options(${TEST_NAME} PRIVATE -flto -Wl,--allow-multiple-definition) +target_link_libraries(${TEST_NAME} PUBLIC runtime mglib) + +add_custom_command( + TARGET ${TEST_NAME} + POST_BUILD + COMMAND ${CMAKE_OBJDUMP} -dhS -Mmarch=${ISA} $ > $.s) diff --git a/tests/magia/mesh/mm_os_mglib/include/test.h b/tests/magia/mesh/mm_os_mglib/include/test.h new file mode 100644 index 00000000..1e47fa3d --- /dev/null +++ b/tests/magia/mesh/mm_os_mglib/include/test.h @@ -0,0 +1,1903 @@ +// Copyright 2025-2026 ETH Zurich, University of Bologna and Fondazione Chips-IT. +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// Alberto Dequino +// Victor Isachi + +#ifndef _TEST_MM_OS_2_INCLUDE_GUARD_ +#define _TEST_MM_OS_2_INCLUDE_GUARD_ + +#define M_SIZE (96) +#define N_SIZE (64) +#define K_SIZE (64) + +// uint16_t y_out [M_SIZE * K_SIZE] = {0}; + +uint16_t x_inp[M_SIZE * N_SIZE] = { + 0x3bc4, 0x38a8, 0x3af4, 0x3701, 0x3677, 0x310f, 0x3246, 0x3962, 0x390e, 0x3011, 0x395a, 0x3ba5, + 0x37a9, 0x33b9, 0x345b, 0x39b9, 0x3a80, 0x389d, 0x3627, 0x397a, 0x3bb4, 0x2de4, 0x3b76, 0x3a79, + 0x2cc5, 0x3b89, 0x3b94, 0x3af8, 0x3845, 0x3999, 0x3207, 0x38e2, 0x387f, 0x34e4, 0x3bdb, 0x3b9d, + 0x2d95, 0x3822, 0x3b17, 0x38b0, 0x38d2, 0x300f, 0x3b47, 0x3122, 0x3989, 0x3a59, 0x3bf0, 0x3b60, + 0x2be0, 0x39c4, 0x260c, 0x3998, 0x39e4, 0x327a, 0x3401, 0x3a19, 0x3922, 0x3759, 0xe48, 0x3500, + 0x3560, 0x30a7, 0x3a20, 0x39a9, 0x360b, 0x23aa, 0x38ec, 0x399b, 0x3aea, 0x39f1, 0x3311, 0x398d, + 0x386b, 0x35d3, 0x2e37, 0x31e0, 0x3216, 0x2f54, 0x36c8, 0x3a38, 0x33ff, 0x3970, 0x33a8, 0x355f, + 0x3171, 0x35c2, 0x320c, 0x3bd0, 0x348a, 0x3bd1, 0x3b6d, 0x364c, 0x3848, 0x3819, 0x3869, 0x3a95, + 0x3882, 0x29d3, 0x3272, 0x3146, 0x1ca2, 0x38cb, 0x38d8, 0x3b7b, 0x2e55, 0x3aea, 0x388e, 0x3b73, + 0x1e9f, 0x3921, 0x3878, 0x3aba, 0x388f, 0x3724, 0x3b21, 0x3752, 0x2a4a, 0x3802, 0x321d, 0x3a56, + 0x3430, 0x38f7, 0x24e9, 0x3a57, 0x39a3, 0x3985, 0x3bcb, 0x3bd9, 0x34ad, 0x3352, 0x3006, 0x39ec, + 0x3afb, 0x34eb, 0x34ff, 0x3007, 0x37e5, 0x37ef, 0x3953, 0x3703, 0x3468, 0x39af, 0x3bc4, 0x34ee, + 0x3ad4, 0x3b92, 0x362e, 0x3b24, 0x3650, 0x2d18, 0x2f09, 0x33f8, 0x2ee8, 0x3b80, 0x3a24, 0x3512, + 0x3bfe, 0x382b, 0x3946, 0x37ad, 0x38df, 0x3a6f, 0x3068, 0x3c00, 0x3a1d, 0x3977, 0x3baa, 0x3776, + 0x398a, 0x374a, 0x3180, 0x30a7, 0x3427, 0x307b, 0x301a, 0x3977, 0x3941, 0x35d1, 0x2e44, 0x37ed, + 0x3205, 0x38d4, 0x34f9, 0x396c, 0x39f0, 0x39f7, 0x3ae1, 0x3788, 0x3186, 0x3956, 0x3852, 0x3515, + 0x3963, 0x3706, 0x3836, 0x2fa5, 0x2e7c, 0x399e, 0x3695, 0x3152, 0x3a61, 0x36e1, 0x2cb5, 0x22ba, + 0x3952, 0x249b, 0x39c2, 0x39ce, 0x3aa6, 0x374c, 0x3704, 0x397d, 0x395e, 0x3b34, 0x3ba0, 0x3bbd, + 0x3b40, 0x39b3, 0x3917, 0x3a15, 0x35eb, 0x38c7, 0x3451, 0x35f6, 0x3a2f, 0x365d, 0x3a9d, 0x3952, + 0x3ae6, 0x3a96, 0x29b1, 0x3a12, 0x3a63, 0x3931, 0x340e, 0x3579, 0x3500, 0x340d, 0x31c5, 0x3ab8, + 0x3a99, 0x339a, 0x36df, 0x3494, 0x37af, 0x3938, 0x1a95, 0x3b76, 0x38f2, 0x2ac6, 0x39f4, 0x3b59, + 0x36b9, 0x2555, 0x35c2, 0x3969, 0x3475, 0x3473, 0x3b1d, 0x3752, 0x2c50, 0x37e5, 0x35d2, 0x2406, + 0x3639, 0x3adc, 0x32e5, 0x3a43, 0x2979, 0x2cd5, 0x37bc, 0x3a9a, 0x3976, 0x3832, 0x3260, 0x2cda, + 0x364e, 0x387a, 0x2444, 0x3904, 0x363a, 0x2a47, 0x397e, 0x3629, 0x3b66, 0x34b7, 0x393c, 0x2281, + 0x39ad, 0x36ac, 0x2e58, 0x34d0, 0x361d, 0x2acb, 0x3a81, 0x3acf, 0x394c, 0x2497, 0x2679, 0x3a66, + 0x34dc, 0x3b93, 0x2cac, 0x3b08, 0x38e5, 0x3826, 0x3a0b, 0x3989, 0x3254, 0x319b, 0x2d3b, 0x39cf, + 0x36c0, 0x38b5, 0x31e4, 0x38ad, 0x3b10, 0x3a46, 0x3004, 0x3afb, 0x341f, 0x3ae8, 0x3a72, 0x3ac7, + 0x31c8, 0x3795, 0x3400, 0x355b, 0x3974, 0x3090, 0x3870, 0x2e3c, 0x38de, 0x2192, 0x3341, 0x3a27, + 0x2be6, 0x1e7b, 0x38de, 0x3049, 0x3b3a, 0x3320, 0x30b3, 0x30dd, 0x3525, 0x357b, 0x3981, 0x3430, + 0x3796, 0x3a14, 0x2dae, 0x3857, 0x385f, 0x3aa4, 0x350c, 0x32d4, 0x300a, 0x3a89, 0x3847, 0x38f7, + 0x33d8, 0x3755, 0x2bf7, 0x3ab1, 0x3a3b, 0x39fd, 0x30ef, 0x3780, 0x3ba9, 0x31b6, 0x3467, 0x35a8, + 0x3aa7, 0x35f9, 0x3a0e, 0x392b, 0x3241, 0x383b, 0x3a98, 0x3af2, 0x39d1, 0x2df0, 0x39af, 0x3715, + 0x37c8, 0x345c, 0x3af4, 0x3859, 0x398e, 0x36c8, 0x3685, 0x3b9a, 0x3674, 0x3b11, 0x35a1, 0x39fa, + 0x320f, 0x3ada, 0x3220, 0x3a00, 0x39a1, 0x3954, 0x3bfe, 0x36f3, 0x3533, 0x2a58, 0x360b, 0x379b, + 0x39c8, 0x3a2a, 0x3070, 0x3bcd, 0x384d, 0x3386, 0x38b7, 0x2cd8, 0x37e5, 0x3b9a, 0x3900, 0x39c7, + 0x3849, 0x3a0b, 0x3a58, 0x3bd2, 0x3a57, 0x32e6, 0x365d, 0x2d29, 0x38f3, 0x38ae, 0x3bbf, 0x3459, + 0x3580, 0x3547, 0x3546, 0x39dd, 0x2cb5, 0x35fb, 0x37f9, 0x3b83, 0x32e6, 0x3875, 0x33ce, 0x3039, + 0x31f5, 0x386e, 0x3aec, 0x3bea, 0x3beb, 0x3bee, 0x3972, 0x3853, 0x28f1, 0x35a0, 0x2d66, 0x343d, + 0x39dd, 0x31a7, 0x36f6, 0x2df4, 0x3be1, 0x2bb2, 0x3a34, 0x31f3, 0x3286, 0x363c, 0x3318, 0x33f4, + 0x394f, 0x303d, 0x36ae, 0x3579, 0x3830, 0x33fe, 0x39b3, 0x3ae0, 0x3b94, 0x3410, 0x1846, 0x2f50, + 0x3ad9, 0x29b4, 0x3b2d, 0x358a, 0x3ba5, 0x3b45, 0x2822, 0x3b0e, 0x2f3c, 0x2f5d, 0x34d2, 0x3adc, + 0x391c, 0x3a3d, 0x3143, 0x3af8, 0x38f1, 0x3b05, 0x35b0, 0x3be6, 0x3a75, 0x3afd, 0x3a17, 0x342a, + 0x34df, 0x3bc3, 0x3958, 0x38c9, 0x3a07, 0x3386, 0x30b5, 0x37c7, 0x3191, 0x39e8, 0x2e86, 0x3b1b, + 0x3bf4, 0x2aa1, 0x25c7, 0x34e8, 0x3afe, 0x3a1a, 0x3aa7, 0x3a34, 0x2e88, 0x2f09, 0x34f4, 0x3a41, + 0x37b3, 0x3845, 0x39fc, 0x3845, 0x3a78, 0x3a8c, 0x3a25, 0x3ac7, 0x360c, 0x3992, 0x38ac, 0x3984, + 0x390c, 0x383b, 0x3361, 0x3b1f, 0x322f, 0x3acf, 0x377c, 0x3aff, 0x392b, 0x384b, 0x303f, 0x3a2c, + 0x3975, 0x386f, 0x366a, 0x38b3, 0x3504, 0x3bb3, 0x3403, 0x2acd, 0x3bac, 0x31f8, 0x390d, 0x35b6, + 0x38f7, 0x293a, 0x368c, 0x384f, 0x3b65, 0x38c9, 0x3736, 0x38c1, 0x3af3, 0x3950, 0x2d07, 0x3486, + 0x397b, 0x3bdd, 0x3beb, 0x3bcb, 0x33e6, 0x320f, 0x3a6c, 0x2edd, 0x3765, 0x3976, 0x387e, 0x3aa5, + 0x2edd, 0x3b15, 0x2ca9, 0x3ae3, 0x33a2, 0x34fe, 0x3ae7, 0x3895, 0x38d4, 0x2927, 0x3b84, 0x3964, + 0x3224, 0x298a, 0x3560, 0x2aef, 0x38fc, 0x3826, 0x3ad0, 0x3bf3, 0x3bc7, 0x3604, 0x3729, 0x37b9, + 0x385e, 0x2962, 0x3598, 0x3118, 0x3a34, 0x3990, 0x2c5a, 0x3684, 0x31f8, 0x3a3a, 0x3900, 0x367a, + 0x3afb, 0x364e, 0x3857, 0x3886, 0x3339, 0x3875, 0x3bed, 0x3569, 0x35b4, 0x3879, 0x34e4, 0x3a0e, + 0x3836, 0x3a15, 0x36b3, 0x33c8, 0x29ce, 0x3774, 0x2c8b, 0x35d1, 0x39f0, 0x3b59, 0x2f54, 0x3b66, + 0x2ba4, 0x38b9, 0x39a0, 0x383c, 0x39fb, 0x3458, 0x2c62, 0x3a07, 0x3b25, 0x344c, 0x387d, 0x383a, + 0x38f9, 0x2e96, 0x38cf, 0x3539, 0x30b7, 0x3b0c, 0x3472, 0x34ec, 0x2c32, 0x3ae0, 0x39d9, 0x3875, + 0x3b85, 0x3bc7, 0x3bfe, 0x3079, 0x3b26, 0x3521, 0x38cb, 0x3285, 0x3589, 0x39d2, 0x3aae, 0x3b7b, + 0x3808, 0x3a3e, 0x238e, 0x3882, 0x3af6, 0x2c22, 0x3873, 0x3992, 0x3b01, 0x34a6, 0x3a2f, 0x3b23, + 0x2e9c, 0x2656, 0x3614, 0x3590, 0x3572, 0x378d, 0x38f1, 0x3271, 0x36b3, 0x3896, 0x2f55, 0x2ab4, + 0x37eb, 0x39ca, 0x381d, 0x3594, 0x3432, 0x3b6b, 0x37e0, 0x372f, 0x3b3f, 0x392a, 0x39ed, 0x35fc, + 0x3938, 0x3b51, 0x3b37, 0x33dc, 0x38d6, 0x30d8, 0x330b, 0x3b61, 0x3a8f, 0x3aa3, 0x3adb, 0x3ae7, + 0x3359, 0x39e1, 0x2c94, 0x3093, 0x38e9, 0x3b42, 0x390d, 0x3b01, 0x3a8c, 0x3886, 0x3b4d, 0x3a30, + 0x30d4, 0x33a8, 0x3498, 0x35a2, 0x3b02, 0x3573, 0x345f, 0x35a2, 0x3181, 0x212d, 0x34bf, 0x396c, + 0x19e4, 0x3992, 0x38fa, 0x3af9, 0x2e49, 0x3a1c, 0x27b3, 0x3777, 0x3868, 0x320c, 0x340e, 0x3028, + 0x39e9, 0x3832, 0x391f, 0x372b, 0x363f, 0x3aa8, 0x39a0, 0x3637, 0x2ba4, 0x3810, 0x3bef, 0x3ae1, + 0x397f, 0x3521, 0x3b71, 0x30ca, 0x2478, 0x2b91, 0x39ed, 0x38ea, 0x31ed, 0x3b37, 0x3a7a, 0x3a2f, + 0x387e, 0x367c, 0x39d0, 0x3a52, 0x36ab, 0x39ad, 0x3976, 0x3b80, 0x3b6b, 0x35f6, 0x3bf9, 0x3171, + 0x3977, 0x3b37, 0x28e7, 0x3403, 0x34fd, 0x3889, 0x35d4, 0x2686, 0x3b82, 0x3455, 0x3041, 0x389f, + 0x3ac9, 0x34b1, 0x3576, 0x3a6e, 0x3495, 0x31f8, 0x3a90, 0x3a77, 0x3a00, 0x38ba, 0x34a0, 0x3a5a, + 0x354a, 0x39da, 0x39a9, 0x302e, 0x3bcd, 0x328d, 0x2c1c, 0x3b9d, 0x3bad, 0x399a, 0x35be, 0x3b2a, + 0x36f8, 0x332d, 0x39ef, 0x3b78, 0x36a5, 0x30d8, 0x3b69, 0x2fe0, 0x3a22, 0x3a87, 0x332f, 0x39d5, + 0x34da, 0x3023, 0x26b2, 0x3712, 0x3976, 0x3bae, 0x39ee, 0x36aa, 0x3783, 0x34ca, 0x1dda, 0x3a22, + 0x35b9, 0x3688, 0x3a33, 0x389f, 0x377b, 0x3908, 0x3262, 0x3844, 0x30c5, 0x352e, 0x2889, 0x3b4a, + 0x36b4, 0x3b8c, 0x316f, 0x3892, 0x3281, 0x3bcb, 0x304f, 0x395b, 0x3bff, 0x3af7, 0x38a6, 0x313f, + 0x3965, 0x3a2f, 0x372c, 0x390b, 0x2ccf, 0x3a3c, 0x3bfb, 0x3932, 0x3ab8, 0x33bf, 0x3b6a, 0x370f, + 0x33a2, 0x2b19, 0x2f7e, 0x3558, 0x38b6, 0x3a17, 0x3306, 0x37dd, 0x3a84, 0x2c33, 0x3b3b, 0x2e32, + 0x2d2b, 0x389b, 0x378a, 0x3667, 0x31f5, 0x3823, 0x395a, 0x3a40, 0x3004, 0x390c, 0x398c, 0x37c4, + 0x3497, 0x394a, 0x3af6, 0x3729, 0x2a73, 0x3881, 0x3227, 0x39c6, 0x379f, 0x3b06, 0x287f, 0x3aff, + 0x3bdb, 0x38cc, 0x36e7, 0x31c6, 0x3b4c, 0x2994, 0x3873, 0x36f2, 0x3b4f, 0x3266, 0x3acb, 0x3339, + 0x36e8, 0x38a9, 0x38cd, 0x3144, 0x39d8, 0x39f0, 0x301f, 0x3a70, 0x34ac, 0x364e, 0x3489, 0x3af8, + 0x3886, 0x2fa4, 0x3b96, 0x388b, 0x389c, 0x363c, 0x3905, 0x32d5, 0x39c9, 0x3be6, 0x2dbd, 0x34c0, + 0x3b00, 0x3a39, 0x3044, 0x2561, 0x349c, 0x3b97, 0x3855, 0x387e, 0x3a7d, 0x22e5, 0x393f, 0x34a5, + 0x3ae2, 0x2e0c, 0x3b44, 0x3a1b, 0x39b2, 0x3836, 0x2ea4, 0x3936, 0x36be, 0x308e, 0x3907, 0x3b3e, + 0x2828, 0x377d, 0x3bfd, 0x2eb0, 0x327c, 0x2293, 0x2f1d, 0x37a7, 0x39e9, 0x347c, 0x3b6f, 0x3ac4, + 0x3422, 0x349e, 0x3a60, 0x3884, 0x3ae3, 0x3a81, 0x3b1f, 0x285b, 0x3494, 0x35a2, 0x31f5, 0x3ad3, + 0x3834, 0x3ae7, 0x3bfa, 0x3678, 0x373f, 0x3739, 0x3afd, 0x347f, 0x38d8, 0x3a1d, 0x39c9, 0x3644, + 0x3909, 0x307a, 0x3827, 0x3ae1, 0x38a0, 0x3ac1, 0x3bac, 0x3b31, 0x3a58, 0x217b, 0x3a9d, 0x3519, + 0x3893, 0x3a17, 0x38aa, 0x3334, 0x3515, 0x3784, 0x3bbe, 0x3b54, 0x38de, 0x36bc, 0x31ab, 0x3acb, + 0x3a5c, 0x3934, 0x3457, 0x2724, 0x39d0, 0x332c, 0x38ce, 0x3b4d, 0x391a, 0x354c, 0x3741, 0x2be2, + 0x39e1, 0x3ad4, 0x3bf9, 0x2c7d, 0x2cfb, 0x3186, 0x2e4a, 0x3647, 0x3729, 0x37fe, 0x34e9, 0x3753, + 0x39e2, 0x2c12, 0x3216, 0x3825, 0x341b, 0x271c, 0x36b3, 0x3bd8, 0x38bf, 0x3856, 0x39c0, 0x3b60, + 0x3755, 0x3bd8, 0x3a87, 0x2cde, 0x37fd, 0x36f4, 0x3859, 0x38ff, 0x34f2, 0x302b, 0x3a1a, 0x31c6, + 0x3998, 0x3ac2, 0x3872, 0x3b87, 0x352a, 0x39d2, 0x38a9, 0x3bc1, 0x3b63, 0x38fc, 0x3132, 0x3bb9, + 0x3bcf, 0x2c64, 0x34f7, 0x3967, 0x2d54, 0x3a1f, 0x3466, 0x2c70, 0x3913, 0x3b00, 0x38d5, 0x3b0c, + 0x2d8c, 0x32cf, 0x3201, 0x3b98, 0x3bc7, 0x2e2b, 0x2b75, 0x3b70, 0x338a, 0x3897, 0x34ec, 0x3b71, + 0x3b2e, 0x3832, 0x2ea1, 0x3a9d, 0x354d, 0x3266, 0x3445, 0x3487, 0x3bbb, 0x3bdb, 0x3727, 0x39a3, + 0x331b, 0x3bd7, 0x3bd5, 0x378e, 0x3319, 0x2c10, 0x2bd6, 0x3b36, 0x2dbd, 0x2aaf, 0x3155, 0x2da3, + 0x288a, 0x36e2, 0x3ab6, 0x3a38, 0x3653, 0x3916, 0x3880, 0x3aaa, 0x2e8c, 0x37cd, 0x38b1, 0x3588, + 0x382a, 0x3a6e, 0x3551, 0x39d5, 0x2b49, 0x3bb0, 0x3ba3, 0x38a1, 0x38b0, 0x345c, 0x303c, 0x33e5, + 0x31f6, 0x396b, 0x2ef3, 0x3bc1, 0x356f, 0x3467, 0x3b2e, 0x39db, 0x3635, 0x2980, 0x3b5f, 0x3443, + 0x387d, 0x3948, 0x3a84, 0x3127, 0x399e, 0x35c8, 0x3b22, 0x3696, 0x336c, 0x3acc, 0x38c1, 0x34b5, + 0x3039, 0x36ac, 0x3a92, 0x3a3b, 0x370c, 0x3297, 0x39af, 0x2f5f, 0x3854, 0x3b42, 0x3a92, 0x3002, + 0x3a9a, 0x365c, 0x3110, 0x2c8d, 0x3b95, 0x3ba7, 0x3bb4, 0x339f, 0x3982, 0x3b30, 0x30e2, 0x34b3, + 0x38c5, 0x34f0, 0x2c49, 0x2bed, 0x33e1, 0x3571, 0x3a9c, 0x38fa, 0x3b36, 0x39ca, 0x3890, 0x2f8a, + 0x3a92, 0x33fb, 0x2e28, 0x38fb, 0x381d, 0x34c9, 0x2a9c, 0x3754, 0x395d, 0x3821, 0x2b53, 0x1f32, + 0x39d6, 0x3a4a, 0x3967, 0x3962, 0x343d, 0x3718, 0x3448, 0x32b2, 0x32f5, 0x3a8e, 0x3adb, 0x3a95, + 0x30de, 0x22a1, 0x331c, 0x341d, 0x272b, 0x302a, 0x30f3, 0x305c, 0x3b8d, 0x39fa, 0x2f48, 0x395a, + 0x37bf, 0x3767, 0x36cb, 0x39f8, 0x395b, 0x399e, 0x39bd, 0x3a3f, 0x3bc8, 0x3bd8, 0x360c, 0x3b70, + 0x3b7a, 0x3be9, 0x35ed, 0x361f, 0x303f, 0x3afd, 0x3452, 0x3ab3, 0x348a, 0x3760, 0x3628, 0x392a, + 0x3039, 0x33c8, 0x2af5, 0x389f, 0x34b2, 0x2497, 0x3ae0, 0x35a9, 0x3759, 0x3a13, 0x383c, 0x38e7, + 0x3232, 0x2d3c, 0x3aae, 0x3211, 0x397e, 0x374c, 0x3060, 0x2d74, 0x29b5, 0x3937, 0x2ed0, 0x3a76, + 0x3acc, 0x3658, 0x372c, 0x34c8, 0x3aab, 0x36c6, 0x32ee, 0x3a0d, 0x2ddc, 0x3730, 0x38ee, 0x2841, + 0x317f, 0x360d, 0x3a2a, 0x388a, 0x3b33, 0x30e3, 0x3b9e, 0x3a6b, 0x345c, 0x36ae, 0x3b1e, 0x3107, + 0x347f, 0x3b7d, 0x38d7, 0x3815, 0x3a0b, 0x36e9, 0x3bbc, 0x3124, 0x3b17, 0x390d, 0x286a, 0x3625, + 0x383a, 0x2813, 0x3aed, 0x365a, 0x1e11, 0x3be7, 0x34cf, 0x3a56, 0x3856, 0x3af5, 0x39ff, 0x383d, + 0x33b8, 0x3a9a, 0x36f4, 0x2df6, 0x3b48, 0x2fd6, 0x2a61, 0x3675, 0x2e35, 0x3a43, 0x3a57, 0x352b, + 0x30b7, 0x2d22, 0x3768, 0x347f, 0x3874, 0x3b90, 0x30c4, 0x3a13, 0x3293, 0x2c06, 0x2293, 0x3414, + 0x35d9, 0x3b43, 0x3154, 0x27b4, 0x3a09, 0x39d8, 0x366d, 0x3a02, 0x37fa, 0x3306, 0x3837, 0x37ee, + 0x30e8, 0x3a91, 0x388d, 0x3933, 0x39c7, 0x30ef, 0x3962, 0x36bb, 0x2961, 0x3868, 0x34c5, 0x3a6c, + 0x30ab, 0x34b9, 0x3bab, 0x39e1, 0x3669, 0x338c, 0x32fc, 0x39b4, 0x37f3, 0x39ba, 0x3619, 0x2e01, + 0x3901, 0x331d, 0x366f, 0x3c00, 0x3718, 0x389e, 0x38b9, 0x2c69, 0x3839, 0x3abc, 0x388a, 0x3a02, + 0x36cf, 0x3ad6, 0x3bbd, 0x35a5, 0x3b33, 0x3827, 0x368d, 0x3abf, 0x3968, 0x359c, 0x307f, 0x31b2, + 0x38e7, 0x3b34, 0x3a6b, 0x38aa, 0x386e, 0x3973, 0x3623, 0x3503, 0x3660, 0x345b, 0x3978, 0x3ba2, + 0x338f, 0x3a8c, 0x32fa, 0x26ff, 0x3bca, 0x3baf, 0x388a, 0x3b02, 0x3818, 0x3856, 0x37a9, 0x28d4, + 0x311b, 0x3a90, 0x27ba, 0x3b29, 0x3693, 0x3211, 0x2fe8, 0x341c, 0x2d6c, 0x30cf, 0x3a46, 0x3a6a, + 0x36e5, 0x3a30, 0x3804, 0x32af, 0x3b29, 0x1168, 0x3a46, 0x382e, 0x3117, 0x3a01, 0x3b4a, 0x2dfd, + 0x3b41, 0x3a63, 0x36d3, 0x3b8e, 0x3be4, 0x27c8, 0x35de, 0x3ae8, 0x304f, 0x3894, 0x3641, 0x33bb, + 0x2edd, 0x32e6, 0x39f2, 0x3820, 0x3944, 0x2f14, 0x3864, 0x3ac4, 0x3ad8, 0x34d9, 0x38de, 0x3561, + 0x3a28, 0x372c, 0x3950, 0x3837, 0x3472, 0x3aec, 0x3a2c, 0x38e1, 0x3a27, 0x359d, 0x2f52, 0x35f9, + 0x361d, 0x35fb, 0x3bda, 0x3655, 0x359c, 0x2ef6, 0x3b96, 0x2c41, 0x3816, 0x35f9, 0x3857, 0x1c3b, + 0x3aa6, 0x3a08, 0x365d, 0x3406, 0x3544, 0x3b6a, 0x386e, 0x3bf3, 0x3526, 0x36a1, 0x2f31, 0x380a, + 0x372f, 0x357a, 0x3a3c, 0x2d45, 0x35fd, 0x1ac3, 0x385d, 0x31f4, 0x2a80, 0x3853, 0x3b32, 0x3991, + 0x3b13, 0x36f7, 0x3aa6, 0x38c7, 0x3122, 0x3a49, 0x26c8, 0x39f2, 0x2cb5, 0x3872, 0x3b75, 0x37ff, + 0x2e43, 0x2647, 0x3b15, 0x3a4e, 0x36dd, 0x3925, 0x24fb, 0x30ed, 0x31ed, 0x337a, 0x33ca, 0x3139, + 0x3a8d, 0x3b21, 0x3aee, 0x3a2b, 0x3351, 0x3a13, 0x3693, 0x3a21, 0x3979, 0x31ab, 0x345d, 0x3994, + 0x3b48, 0x380b, 0x3b13, 0x3993, 0x386c, 0x3751, 0x39bc, 0x3114, 0x2cd9, 0x2f90, 0x3bf5, 0x2fff, + 0x37ef, 0x3562, 0x3acf, 0x3aeb, 0x3bc4, 0x3406, 0x297f, 0x3b75, 0x3ac7, 0x3a33, 0x395b, 0x15ab, + 0x384f, 0x3877, 0x31b5, 0x3bd3, 0x3a7c, 0x3850, 0x3535, 0x3690, 0x3880, 0x38b9, 0x3555, 0x3ada, + 0x3beb, 0x3bcb, 0x30cf, 0x32ec, 0x3181, 0x3a79, 0x3b65, 0x383c, 0x370d, 0x3b64, 0x3b26, 0x2ea8, + 0x3a5e, 0x3474, 0x34b3, 0x3aa3, 0x2e62, 0x3b3c, 0x395d, 0x3a0c, 0x3788, 0x3254, 0x3160, 0x34d5, + 0x39c3, 0x39a1, 0x38ef, 0x2e85, 0x3923, 0x39ec, 0x38da, 0x397b, 0x38d8, 0x3919, 0x3a6c, 0x2aa3, + 0x3acc, 0x346a, 0x36d0, 0x3b5b, 0x3202, 0x3af3, 0x3713, 0x2262, 0x2c8f, 0x34cc, 0x30b5, 0x344b, + 0x3a48, 0x3855, 0x33d1, 0x3972, 0x3ab2, 0x363d, 0x382f, 0x30ed, 0x3a54, 0x39be, 0x381f, 0x3443, + 0x3952, 0x37d9, 0x3a56, 0x3bd8, 0x2cae, 0x3617, 0x27f2, 0x3a59, 0x3ab2, 0x30db, 0x358a, 0x394e, + 0x3731, 0x34e7, 0x33c2, 0x340e, 0x3b5d, 0x3be3, 0x3800, 0x3818, 0x3394, 0x32e8, 0x37d6, 0x342e, + 0x3a47, 0x33bc, 0x39fe, 0x3b3d, 0x3834, 0x3034, 0x33dc, 0x2dbd, 0x3524, 0x3b68, 0x319e, 0x3551, + 0x3a33, 0x3927, 0x3889, 0x3a3d, 0x35fe, 0x384d, 0x3607, 0x3246, 0x39f4, 0x3230, 0x3baa, 0x3023, + 0x3be2, 0x270e, 0x3904, 0x3875, 0x318b, 0x3485, 0x2af3, 0x39ac, 0x3a5d, 0x386a, 0x3861, 0x34a1, + 0x3a3c, 0x3bd2, 0x37d6, 0x234f, 0x3535, 0x2d10, 0x30ec, 0x3391, 0x3490, 0x3665, 0x3b33, 0x2cae, + 0x3b86, 0x3a77, 0x3a6d, 0x2606, 0x3b3e, 0x3678, 0x3994, 0x3670, 0x284d, 0x338a, 0x363c, 0x38b7, + 0x1eb8, 0x392f, 0x3b20, 0x342f, 0x3b77, 0x385e, 0x3867, 0x3a83, 0x3a5e, 0x30f7, 0x3580, 0x3773, + 0x3831, 0x3b4c, 0x397d, 0x3b67, 0x3756, 0x385d, 0x3019, 0x38f7, 0x3834, 0x3262, 0x3ae0, 0x3bc3, + 0x25d9, 0x3421, 0x3b51, 0x3935, 0x2e27, 0x34fe, 0x3bb4, 0x2882, 0x39fd, 0x36d1, 0x29e4, 0x32fb, + 0x3937, 0x36a9, 0x375c, 0x3a0d, 0x3826, 0x3b2b, 0x332f, 0x3a92, 0x328f, 0x365d, 0x376c, 0x38e2, + 0x3b2c, 0x348c, 0x312a, 0x2c9b, 0x3a6c, 0x3b0c, 0x358e, 0x3a26, 0x3b0e, 0x2fcb, 0x3360, 0x325b, + 0x35ee, 0x360b, 0x3b5f, 0x3598, 0x31c8, 0x3ad2, 0x398a, 0x2c7f, 0x2bdf, 0x37ef, 0x3933, 0x3840, + 0x36fb, 0x37d2, 0x3631, 0x3932, 0x3423, 0x3b0a, 0x3736, 0x2fce, 0x3462, 0x3a7c, 0x3446, 0x324c, + 0x36e7, 0x2c2b, 0x35d9, 0x372d, 0x329d, 0x3900, 0x313d, 0x3be1, 0x39fc, 0x3969, 0x3bcf, 0x3bcb, + 0x3883, 0x31e7, 0x3009, 0x380b, 0x3a4a, 0x2641, 0x3868, 0x390d, 0x373e, 0x3954, 0x3664, 0x3226, + 0x3a82, 0x3a1b, 0x34d8, 0x2a59, 0x3457, 0x31bd, 0x35b9, 0x32a3, 0x38d9, 0x39d8, 0x2484, 0x31f4, + 0x3734, 0x3a15, 0x38e2, 0x35b1, 0x397a, 0x31f2, 0x3669, 0x3502, 0x2e64, 0x3bd7, 0x3bf4, 0x3b39, + 0x3774, 0x3809, 0x34b3, 0x3a3d, 0x364c, 0x3658, 0x388d, 0x3a5f, 0x386e, 0x39ba, 0x3917, 0x385b, + 0x3990, 0x3782, 0x399a, 0x3077, 0x3932, 0x3765, 0x3484, 0x3ba4, 0x3111, 0x3ae7, 0x384a, 0x38ed, + 0x3921, 0x2e50, 0x3af8, 0x2c79, 0x3967, 0x35c2, 0x3257, 0x3355, 0x3512, 0x3b09, 0x3a2b, 0x38db, + 0x3282, 0x39b2, 0x3a11, 0x3b5b, 0x3124, 0x3072, 0x2581, 0x37c1, 0x3868, 0x388a, 0x3b1f, 0x3867, + 0x304a, 0x391c, 0x3a69, 0x3496, 0x3ad3, 0x3ad8, 0x3b55, 0x3540, 0x3a99, 0x2fcb, 0x3a50, 0x3a9b, + 0x2c06, 0x3547, 0x3841, 0x338d, 0x27bd, 0x2fdc, 0x3a40, 0x39ab, 0x305e, 0x3816, 0x3b18, 0x2c0f, + 0x3ac2, 0x3b9a, 0x36e3, 0x3912, 0x38f0, 0x3b5a, 0x3583, 0x3a2f, 0x3805, 0x381c, 0x389b, 0x39bc, + 0x3939, 0x3062, 0x3981, 0x39c5, 0x2fe2, 0x3a83, 0x2fd7, 0x399e, 0x309d, 0x3bd9, 0x3847, 0x37cb, + 0x3855, 0x2e0c, 0x385f, 0x3a90, 0x3837, 0x3569, 0x39a7, 0x35cf, 0x3aab, 0x3998, 0x3903, 0x3857, + 0x3a05, 0x3b11, 0x35dc, 0x31ef, 0x36d3, 0x3a6b, 0x39cd, 0x316e, 0x2a9b, 0x3522, 0x3a61, 0x3948, + 0x32aa, 0x3940, 0x35b2, 0x38b8, 0x25c7, 0x38e3, 0x38c3, 0x3592, 0x26ee, 0x37c4, 0x3064, 0x3a9f, + 0x36f9, 0x3669, 0x36b9, 0x2d38, 0x38bc, 0x361b, 0x3b45, 0x3a97, 0x3964, 0x3157, 0x26c0, 0x3bd1, + 0x27a7, 0x2bcd, 0x3455, 0x39c8, 0x37cb, 0x2b98, 0x3a97, 0x3773, 0x2efc, 0x307c, 0x3510, 0x3a33, + 0x3806, 0x35a2, 0x3b28, 0x38f9, 0x3bc2, 0x36db, 0x3aa1, 0x3ac3, 0x31aa, 0x3a3d, 0x3ac3, 0x3b73, + 0x31d5, 0x38f8, 0x303b, 0x3929, 0x38eb, 0x3a91, 0x3885, 0x3a64, 0x36bc, 0x381f, 0x36b3, 0x3846, + 0x38d4, 0x3a0a, 0x389f, 0x2c1e, 0x31ca, 0x3934, 0x31b2, 0x378d, 0x2d09, 0x3bed, 0x39ca, 0x3ae0, + 0x36a7, 0x2814, 0x391e, 0x3a62, 0x3bca, 0x381c, 0x34b6, 0x38ec, 0x3920, 0x3830, 0x39fc, 0x3911, + 0x3a42, 0x3372, 0x375b, 0x312b, 0x3604, 0x2ea4, 0x3367, 0x36fd, 0x2dd9, 0x366c, 0x3054, 0x3749, + 0x29ac, 0x37de, 0x39bb, 0x34d5, 0x2e7d, 0x39e9, 0x19c6, 0x3a9a, 0x3bbb, 0x33a5, 0x3556, 0x38a2, + 0x3bfb, 0x3b91, 0x39fa, 0x3aaf, 0x38a7, 0x38b6, 0x285c, 0x3820, 0x2ef2, 0x25f9, 0x3ab0, 0x3bc7, + 0x3457, 0x352f, 0x38e2, 0x31aa, 0x283d, 0x3728, 0x33fe, 0x2d40, 0x2e06, 0x389f, 0x3b2f, 0x3ad4, + 0x39b4, 0x36be, 0x3837, 0x351a, 0x3bb6, 0x3971, 0x3a47, 0x3758, 0x3572, 0x31aa, 0x2825, 0x375c, + 0x344f, 0x3b7e, 0x391b, 0x32b3, 0x3119, 0x23d5, 0x305d, 0x361b, 0x380b, 0x28d4, 0x39f8, 0x3bd2, + 0x383b, 0x39e9, 0x3a81, 0x214f, 0x31a6, 0x3645, 0x38c1, 0x38e1, 0x32f6, 0x385d, 0x357a, 0x35a7, + 0x388a, 0x3ba7, 0x23fb, 0x3853, 0x39db, 0x342d, 0x32fe, 0x3ac4, 0x3b82, 0x3709, 0x35f2, 0x3864, + 0x3b71, 0x344f, 0x38be, 0x3b12, 0x34df, 0x34fe, 0x3715, 0x3864, 0x3968, 0x354c, 0x2af1, 0x39d4, + 0x3b53, 0x39f3, 0x3776, 0x387f, 0x3711, 0x3b77, 0x3565, 0x3aa9, 0x3a99, 0x35f2, 0x369a, 0x3b29, + 0x3811, 0x314b, 0x37f4, 0x3ad5, 0x3753, 0x3ab4, 0x399e, 0x3b00, 0x2dcc, 0x3a9f, 0x3307, 0x34b4, + 0x3ad7, 0x38e8, 0x396a, 0x32af, 0x3886, 0x36e6, 0x3429, 0x377d, 0x3212, 0x3afb, 0x257b, 0x3b85, + 0x3b80, 0x3b0e, 0x2b3e, 0x3ae1, 0x331a, 0x3890, 0x372d, 0x3425, 0x32eb, 0x35af, 0x3a18, 0x39a0, + 0x3908, 0x317a, 0x388b, 0x2eb6, 0x3993, 0x341e, 0x353d, 0x37cc, 0x357d, 0x3ad0, 0x3bee, 0x362e, + 0x343a, 0x372b, 0x3a97, 0x3aea, 0x3bfd, 0x3800, 0x34f0, 0x38ad, 0x2e3e, 0x38e7, 0x393e, 0x35a4, + 0x382a, 0x37a0, 0x3bc7, 0x391f, 0x3212, 0x3aae, 0x23cf, 0x3683, 0x3983, 0x3361, 0x3995, 0x3a38, + 0x36cf, 0x3833, 0x3667, 0x3ac7, 0x3acc, 0x3673, 0x33e3, 0x38de, 0x358d, 0x3ba9, 0x3741, 0x3127, + 0x3a48, 0x3b39, 0x34c6, 0x38cb, 0x3474, 0x3be7, 0x214f, 0x2ddc, 0x392c, 0x3589, 0x3836, 0x3920, + 0x3be0, 0x3651, 0x35a1, 0x3902, 0x2cf1, 0x3b6a, 0x38ff, 0x2c2a, 0x3b70, 0x372b, 0x3846, 0x3ab3, + 0x38c4, 0x3298, 0x38ba, 0x35e2, 0x313f, 0x32a2, 0x3943, 0x34d2, 0x3a36, 0x38a4, 0x3870, 0x3980, + 0x3aa3, 0x37e9, 0x37d8, 0x38d4, 0x3a5d, 0x3bfa, 0x39c1, 0x3a2d, 0x3514, 0x3961, 0x3a4e, 0x3b79, + 0x1ddb, 0x3977, 0x38a0, 0x3989, 0x3752, 0x302f, 0x3b50, 0x345d, 0x32c4, 0x3ba1, 0x3919, 0x3b79, + 0x319b, 0x38ec, 0x39c2, 0x390f, 0x371a, 0x2b0d, 0x2a69, 0x3b72, 0x3b9f, 0x341d, 0x30e6, 0x359a, + 0x3867, 0x39bd, 0x36dc, 0x3b62, 0x3154, 0x380b, 0x3476, 0x2c40, 0x3b50, 0x39a0, 0x3190, 0x3a41, + 0x2ed9, 0x2eae, 0xcf0, 0x2afe, 0x39a8, 0x36ee, 0x34a0, 0x3a0f, 0x3bf8, 0x3a91, 0x38cd, 0x3a3e, + 0x3a26, 0x2528, 0x3ad3, 0x3662, 0x3226, 0x3b2e, 0x332f, 0x323e, 0x394c, 0x3097, 0x2902, 0x3823, + 0x293c, 0x37f2, 0x38c9, 0x3400, 0x39e5, 0x333b, 0x39fc, 0x384a, 0x3955, 0x308e, 0x3796, 0x374a, + 0x306c, 0x30fa, 0x30ee, 0x1f55, 0x34e7, 0x3875, 0x2bc5, 0x3bfa, 0x3635, 0x38e5, 0x3a70, 0x3b49, + 0x3988, 0x3b8c, 0x3a98, 0x3a78, 0x3bfb, 0x3333, 0x3b58, 0x3bd6, 0x3b93, 0x2ef1, 0x3822, 0x34ab, + 0x35c6, 0x384a, 0x34db, 0x3a80, 0x2e05, 0x3ac1, 0x3845, 0x2bd9, 0x3896, 0x288b, 0x38b7, 0x3556, + 0x3095, 0x2c4e, 0x3502, 0x38d5, 0x2c00, 0x34bb, 0x2d06, 0x3b03, 0x28de, 0x3b8b, 0x362a, 0x3642, + 0x3946, 0x3567, 0x3695, 0x39b6, 0x3ae9, 0x3bd9, 0x398d, 0x33e3, 0x381e, 0x3981, 0x3553, 0x35f9, + 0x3499, 0x38b5, 0x3866, 0x298e, 0x38dd, 0x3a7b, 0x3559, 0x34e5, 0x3a6a, 0x336f, 0x30f1, 0x35bb, + 0x3957, 0x3bf8, 0x3a56, 0x3bb5, 0x3b3a, 0x3767, 0x3828, 0x3700, 0x3bda, 0x388a, 0x391c, 0x3937, + 0x3664, 0x382a, 0x37de, 0x2d27, 0x3b6d, 0x3303, 0x3828, 0x3b49, 0x3882, 0x380f, 0x3b93, 0x318a, + 0x33bc, 0x3907, 0x2dbe, 0x3883, 0x3511, 0x2feb, 0x3a76, 0x359c, 0x39c5, 0x3967, 0x3177, 0x314e, + 0x3ad7, 0x33a3, 0x3ae2, 0x3932, 0x27cb, 0x33da, 0x35ad, 0x2c80, 0x369b, 0x3636, 0xdca, 0x2d01, + 0x302c, 0x3950, 0x35d9, 0x3549, 0x3aee, 0x397e, 0x2dfa, 0x3897, 0x30a8, 0x3a71, 0x3a43, 0x3274, + 0x2ec3, 0x3bfc, 0x3ac6, 0x3b9d, 0x3b83, 0x3a01, 0x3b46, 0x32be, 0x3647, 0x35c0, 0x3a99, 0x3515, + 0x3011, 0x3a99, 0x3832, 0x3737, 0xace, 0x303d, 0x3aec, 0x345e, 0x383f, 0x3a7d, 0x2ec5, 0x39ef, + 0x3847, 0x3409, 0x3571, 0x32e0, 0x377d, 0x36d9, 0x3959, 0x2881, 0x32d2, 0x35e3, 0x3ab7, 0x343f, + 0x36ee, 0x30d5, 0x3615, 0x31b5, 0x3a0d, 0x378f, 0x2bbd, 0x28e1, 0x37be, 0x3ad5, 0x261b, 0x3b86, + 0x3470, 0x2f2e, 0x3b44, 0x39a7, 0x3606, 0x38db, 0x3579, 0x3bcd, 0x3291, 0x381c, 0x34f3, 0x39f2, + 0x39c1, 0x39e7, 0x39b3, 0x3667, 0x3001, 0x1483, 0x3888, 0x3962, 0x3719, 0x393f, 0x3a52, 0x37a4, + 0x39f1, 0x3b7d, 0x392d, 0x35d8, 0x3b07, 0x3bd5, 0x3946, 0x3a2a, 0x2f68, 0x2e11, 0x3771, 0x384f, + 0x3612, 0x3bbf, 0x396a, 0x3585, 0x35df, 0x2dc9, 0x3a61, 0x3481, 0x399d, 0x37c4, 0x2fa8, 0x39eb, + 0x2991, 0x2f7a, 0x3adf, 0x3b3d, 0x2f02, 0x39e6, 0x3961, 0x398f, 0x3585, 0x2d8f, 0x39c7, 0x2e85, + 0x319e, 0x3872, 0x3aed, 0x3826, 0x342b, 0x3ad7, 0x25e2, 0x3bc6, 0x326e, 0x3299, 0x28ef, 0x38e9, + 0x3a65, 0x28d7, 0x2098, 0x2481, 0x36f5, 0x3905, 0x3250, 0x389d, 0x24ad, 0x3462, 0x320f, 0x3a33, + 0x3a28, 0x3998, 0x3a01, 0x38ed, 0x39e9, 0x3884, 0x38ea, 0x35b5, 0x316a, 0x35ac, 0x35c7, 0x34b7, + 0x392e, 0x38b1, 0x29cd, 0x35f4, 0x393b, 0x3a3b, 0x3010, 0x3810, 0x3b82, 0x356c, 0x362c, 0x39bb, + 0x39e9, 0x32c1, 0x2fb4, 0x37b3, 0x3ac0, 0x32d7, 0x38d4, 0x35f4, 0x3b9e, 0x2d3c, 0x3b23, 0x2c8d, + 0x31f8, 0x3681, 0x35f4, 0x3693, 0x34aa, 0x386f, 0x3bb2, 0x39b5, 0x30a1, 0x3a9b, 0x38ca, 0x39c0, + 0x3ab5, 0x37a4, 0x3b86, 0x3bac, 0x3478, 0x38b7, 0x3bd0, 0x3b9b, 0x32b8, 0x37cb, 0x3955, 0x3a94, + 0x38c2, 0x3a90, 0x3a96, 0x3948, 0x2cd9, 0x381f, 0x3bf1, 0x3820, 0x2d95, 0x3a8f, 0x37b1, 0x2d54, + 0x38f7, 0x3807, 0x30ca, 0x3b3b, 0x3764, 0x3465, 0x3693, 0x3747, 0x391c, 0x37fa, 0x3295, 0x2974, + 0x29b4, 0x3342, 0x32ba, 0x39a3, 0x37f2, 0x2e0e, 0x2f6c, 0x3bc3, 0x3690, 0x2caa, 0x34f9, 0x2eaf, + 0x2c64, 0x3194, 0x3b90, 0x3716, 0x3958, 0x3310, 0x24ff, 0x35f2, 0x3888, 0x3745, 0x363b, 0x39b9, + 0x36cc, 0x395d, 0x2dc7, 0x37c0, 0x3b1c, 0x3750, 0x3680, 0x38ea, 0x38c8, 0x3a65, 0x355b, 0x3b33, + 0x3965, 0x359d, 0x3a5c, 0x3686, 0x3ac2, 0x3b46, 0x3b71, 0x27fe, 0x397d, 0x36d5, 0x3810, 0x341e, + 0x394f, 0x3a0c, 0x39cd, 0x3794, 0x3aed, 0x3596, 0x2ce8, 0x3172, 0x3023, 0x3ab0, 0x3b9b, 0x3439, + 0x3111, 0x3771, 0x3807, 0x356e, 0x2c3b, 0x3bd9, 0x39a0, 0x366a, 0x388f, 0x2461, 0x3b4a, 0x3895, + 0x39b4, 0x35fb, 0x33c2, 0x36bb, 0x3823, 0x2fac, 0x39ef, 0x35e1, 0x3872, 0x370d, 0x3ac4, 0x323d, + 0x39ee, 0x3be5, 0x325a, 0x39ec, 0x3800, 0x397d, 0x373f, 0x373e, 0x38e4, 0x3ad5, 0x301c, 0x3201, + 0x3a42, 0x3617, 0x3a05, 0x3999, 0x32bd, 0x2d5d, 0x3a09, 0x3423, 0x3ac0, 0x3bc9, 0x3b5d, 0x3ad7, + 0x30c8, 0x3b71, 0x3471, 0x3bbc, 0x2deb, 0x2c18, 0x346f, 0x2a5e, 0x365b, 0x39ea, 0x3b52, 0x349a, + 0x38a1, 0x39f3, 0x3384, 0x3b58, 0x3b6c, 0x34c4, 0x2dde, 0x3b00, 0x3844, 0x389b, 0x385d, 0x35cf, + 0x364a, 0x37f0, 0x3216, 0x3b8f, 0x3539, 0x36c6, 0x30bc, 0x2e04, 0x3741, 0x2f7b, 0x3842, 0x38c0, + 0x36c7, 0x3ada, 0x374d, 0x35c3, 0x327c, 0x379c, 0x3998, 0x349d, 0x2ef4, 0x35e8, 0x2ad0, 0x3912, + 0x3aa7, 0x3ba9, 0x3963, 0x39b2, 0x38f7, 0x2633, 0x38cd, 0x3a42, 0x3213, 0x35fd, 0x31e7, 0x3919, + 0x3b5e, 0x3bb9, 0x3a85, 0x3bfd, 0x1d27, 0x3601, 0x378c, 0x2e32, 0x3990, 0x35ea, 0x39bf, 0x3a33, + 0x38a4, 0x392c, 0x39d2, 0x3aff, 0x3b29, 0x3a3d, 0x2cda, 0x2a0b, 0x3232, 0x3b76, 0x2845, 0x3a9c, + 0x340e, 0x399f, 0x30d9, 0x38dc, 0x37f2, 0x36f6, 0x38de, 0x3a3e, 0x3814, 0x37a6, 0x30e6, 0x3206, + 0x2c05, 0x3bf9, 0x3b8c, 0x3aa5, 0x39b6, 0x39a8, 0x3890, 0x346c, 0x38f7, 0x35e1, 0x38c0, 0x358c, + 0x2602, 0x3067, 0x36bf, 0x2f50, 0x3a41, 0x38d3, 0x3b34, 0x3286, 0x315d, 0x3938, 0x3074, 0x3b53, + 0x34d9, 0x31b3, 0x388c, 0x1842, 0x3a53, 0x371d, 0x3922, 0x3afd, 0x385d, 0x3b95, 0x3646, 0x3821, + 0x2c51, 0x3834, 0x3bac, 0x3431, 0x3b59, 0x388c, 0x2a55, 0x3535, 0x2d62, 0x3557, 0x383e, 0x3079, + 0x3333, 0x3a09, 0x32e4, 0x37c3, 0x358e, 0x39f8, 0x3b29, 0x38a4, 0x3bc9, 0x390a, 0x3868, 0x38e5, + 0x3411, 0x2759, 0x364f, 0x38e1, 0x3b55, 0x3102, 0x3b07, 0x3bec, 0x39c2, 0x3060, 0x323f, 0x3a0c, + 0x373c, 0x3a35, 0x35af, 0x39a1, 0x2431, 0x2ef7, 0x35b6, 0x38fa, 0x3a7a, 0x3412, 0x3717, 0x3713, + 0x34b0, 0x319b, 0x3bbc, 0x3426, 0x3ab3, 0x3615, 0x3ad1, 0x3831, 0x38c4, 0x30a3, 0x3483, 0x38d7, + 0x36c0, 0x33fc, 0x3b94, 0x3601, 0x375f, 0x38f0, 0x317d, 0x39e2, 0x3730, 0x3872, 0x37e5, 0x3a1d, + 0x3a7a, 0x3a60, 0x39a9, 0x380f, 0x35c8, 0x359f, 0x3bcf, 0x38b0, 0x32f3, 0x2c41, 0x3ad3, 0x394a, + 0x3bea, 0x2fab, 0x3892, 0x3aec, 0x3684, 0x38a4, 0x38ae, 0x2f79, 0x3362, 0x35ae, 0x334e, 0x2f11, + 0x3b7e, 0x36c8, 0x3b34, 0x3802, 0x311b, 0x32a5, 0x3a77, 0x38f7, 0x3611, 0x3841, 0x3888, 0x36b5, + 0x32cd, 0x3930, 0x3bf4, 0x3956, 0x3469, 0x3bb2, 0x3add, 0x3bd1, 0x3a15, 0x39d4, 0x3b47, 0x3a69, + 0x382c, 0x3b44, 0x37d2, 0x1e90, 0x3b19, 0x39ca, 0x3176, 0x38a1, 0x3958, 0x38c1, 0x3361, 0x3268, + 0x371f, 0x37e5, 0x39fb, 0x3501, 0x39b9, 0x39c9, 0x3885, 0x3a56, 0x3913, 0x3838, 0x3be9, 0x3150, + 0x37b4, 0x2f1b, 0x350c, 0x2a90, 0x3886, 0x2823, 0x2d33, 0x3867, 0x341f, 0x3939, 0x3771, 0x3794, + 0x3910, 0x3a31, 0x3953, 0x3b16, 0x3a73, 0x3aa2, 0x3a97, 0x3b3d, 0x3473, 0x3881, 0x3a44, 0x333e, + 0x374b, 0x35cc, 0x3a3d, 0x3118, 0x2849, 0x3a11, 0x3855, 0x3a24, 0x3a77, 0x3a97, 0x3807, 0x355a, + 0x3a46, 0x3947, 0x3869, 0x394a, 0x34c5, 0x384f, 0x34c3, 0x36e4, 0x3597, 0x2cc3, 0x222a, 0x3adc, + 0x3738, 0x378f, 0x390e, 0x3b9b, 0x3395, 0x3618, 0x31cb, 0x388a, 0x37a2, 0x39d2, 0x3739, 0x31b6, + 0x3abe, 0x2514, 0x38d8, 0x3860, 0x3b46, 0x2c61, 0x3b7a, 0x3bd3, 0x3bf0, 0x3222, 0x3094, 0x38cf, + 0x3b4c, 0x34e3, 0x1ce4, 0x3079, 0x3799, 0x39cb, 0x37cc, 0x31d5, 0x3477, 0x39be, 0x3b37, 0x3338, + 0x37fb, 0x3a19, 0x3a68, 0x39c5, 0x32df, 0x315c, 0x320d, 0x3636, 0x372b, 0x3504, 0x3742, 0x3a80, + 0x3b24, 0x25de, 0x311d, 0x3b59, 0x3743, 0x3082, 0x3436, 0x3a84, 0x3462, 0x3a6c, 0x2415, 0x3705, + 0x2c28, 0x3154, 0x3381, 0x34c3, 0x3adb, 0x3973, 0x3a99, 0x2f42, 0x3a9c, 0x3be1, 0x378b, 0x3428, + 0x3800, 0x2882, 0x39d6, 0x3819, 0x2e08, 0x33c3, 0x38fe, 0x2db3, 0x3be8, 0x381c, 0x3825, 0x390f, + 0x237d, 0x3b46, 0x27d1, 0x3889, 0x3a43, 0x3650, 0x35f1, 0x3a5a, 0x34e3, 0x387d, 0x2d00, 0x38f8, + 0x37b4, 0x383d, 0x373b, 0x3794, 0x38ab, 0x35e6, 0x31fc, 0x3493, 0x3597, 0x38af, 0x3621, 0x3519, + 0x3bb1, 0x33e4, 0x3782, 0x34a8, 0x2e0b, 0x2db5, 0x377f, 0x33e5, 0x399f, 0x2875, 0x3582, 0x3be0, + 0x3452, 0x3193, 0x3942, 0x3ad2, 0x36d2, 0x3b5a, 0x34fe, 0x2a81, 0x39fd, 0x38ea, 0x3aac, 0x3b11, + 0x3423, 0x3724, 0x3a27, 0x340a, 0x398b, 0x354f, 0x2e4d, 0x35c8, 0x2d73, 0x3a44, 0x2b31, 0x31ec, + 0x3aa2, 0x3b27, 0x3918, 0x34a5, 0x3b9c, 0x2ecb, 0x38b8, 0x2e4e, 0x3b9a, 0x3a36, 0x394a, 0x307a, + 0x2859, 0x344c, 0x3b56, 0x3233, 0x381a, 0x3b75, 0x38c4, 0x386f, 0x350e, 0x2a77, 0x3ad8, 0x3ae6, + 0x3743, 0x3426, 0x3448, 0x3470, 0x3584, 0x38fe, 0x37b1, 0x24b5, 0x2f68, 0x3481, 0x3bac, 0x3b8e, + 0x354e, 0x390e, 0x3824, 0x3045, 0x3aca, 0x36a1, 0x3844, 0x39b9, 0x3a65, 0x3083, 0x318f, 0x3ba1, + 0x3893, 0x341e, 0x3515, 0x2279, 0x352a, 0x3acb, 0x2e04, 0x38fc, 0x389c, 0x2d3f, 0x3363, 0x3a1a, + 0x3ae5, 0x39d8, 0x3a9e, 0x3286, 0x3bd7, 0x38fa, 0x38ff, 0x2cfd, 0x390c, 0x3a2b, 0x2eec, 0x38f8, + 0x3806, 0x3a36, 0x399c, 0x3643, 0x3aa8, 0x373c, 0x37fa, 0x2892, 0x3709, 0x38ae, 0x3800, 0x39ab, + 0x381a, 0x2daa, 0x3306, 0x2c1a, 0x381d, 0x3aad, 0x354e, 0x30c0, 0x3b52, 0x39dc, 0x32b0, 0x30ae, + 0x3bf8, 0x391c, 0x2bb5, 0x3316, 0x2283, 0x33c8, 0x38af, 0x3ab4, 0x314c, 0x39c1, 0x36bd, 0x34b1, + 0x3b52, 0x322e, 0x36dd, 0x37f8, 0x37f1, 0x2173, 0x38e0, 0x29a8, 0x3a7a, 0x32ce, 0x39ce, 0x3836, + 0x3213, 0x32a0, 0x3825, 0x2581, 0x3ab7, 0x36dd, 0x3934, 0x3a29, 0x394b, 0x3a52, 0x3819, 0x3949, + 0x3297, 0x2860, 0x34f2, 0x35b6, 0x3b11, 0x33de, 0x3b82, 0x3b33, 0x3244, 0x3815, 0x3942, 0x3515, + 0x3576, 0x2976, 0x3bda, 0x3929, 0x3976, 0x3949, 0x3ab3, 0x3057, 0x3bf0, 0x384e, 0x3adb, 0x3a6b, + 0x33f1, 0x3a3d, 0x391a, 0x3511, 0x3926, 0x33b9, 0x3363, 0x39b6, 0x393f, 0x3ac1, 0x39d7, 0x34f7, + 0x2c7a, 0x38d9, 0x295f, 0x3658, 0x39d1, 0x31be, 0x337c, 0x39ef, 0x3b76, 0x2820, 0x3a25, 0x39ff, + 0x38da, 0x359c, 0x3556, 0x3b08, 0x300e, 0x3496, 0x2f77, 0x397e, 0x3357, 0x386b, 0x3890, 0x3886, + 0x2baf, 0x32d4, 0x39cb, 0x3312, 0x3bb3, 0x3a33, 0x35be, 0x3831, 0x34ee, 0x32d2, 0x2a8e, 0x3bbf, + 0x260a, 0x3012, 0x38a2, 0x380b, 0x39c6, 0x3098, 0x3aa8, 0x3b87, 0x39de, 0x3403, 0x34a4, 0x36a6, + 0x3a1f, 0x3720, 0x2c49, 0x344c, 0x3b5e, 0x39db, 0x3807, 0x3b45, 0x3925, 0x3b31, 0x3b74, 0x365d, + 0x3970, 0x3ba7, 0x3307, 0x3668, 0x3663, 0x3bbc, 0x3a2b, 0x3154, 0x39a5, 0x3aba, 0x2f5d, 0x3be1, + 0x37d9, 0x31ce, 0x36f0, 0x340b, 0x3882, 0x2ec1, 0x38e5, 0x3bc6, 0x36c2, 0x37a6, 0x3542, 0x34dd, + 0x2c0e, 0x38b8, 0x39c6, 0x3926, 0x381f, 0x33e4, 0x387b, 0x3771, 0x324b, 0x39d2, 0x2c2b, 0x3ad4, + 0x38c9, 0x3b08, 0x2e59, 0x39ae, 0x27e6, 0x3907, 0x35b7, 0x2bbf, 0x38b5, 0x3a6a, 0x39c6, 0x3b6f, + 0x3a94, 0x38aa, 0x303b, 0x3bc8, 0x348e, 0x3ae6, 0x386f, 0x3993, 0x34ec, 0x3bf1, 0x3860, 0x38d9, + 0x3328, 0x3ad6, 0x3220, 0x38ed, 0x37f8, 0x30ac, 0x38a7, 0x2618, 0x3856, 0x30e6, 0x2edf, 0x38c9, + 0x39a5, 0x2ca5, 0x2e15, 0x3af8, 0x324e, 0x33d2, 0x38fe, 0x33de, 0x3be1, 0x308a, 0x3957, 0x39a0, + 0x3a9a, 0x3098, 0x336f, 0x33e8, 0x35c8, 0x3a64, 0x3a6b, 0x39dd, 0x3874, 0x28e0, 0x39e3, 0x3bc5, + 0x3bda, 0x3b31, 0x397d, 0x3121, 0x35a3, 0x385a, 0x26fa, 0x3a6f, 0x3984, 0x39f9, 0x3651, 0x33f9, + 0x3821, 0x3922, 0x39f4, 0x38b7, 0x34ec, 0x3bd3, 0x2c84, 0x28f3, 0x3906, 0x35c3, 0x392f, 0x31d9, + 0x3982, 0x2f17, 0x3511, 0x3b7f, 0x399a, 0x3ab9, 0x2dec, 0x32a5, 0x31c9, 0x335b, 0x3695, 0x3562, + 0x3172, 0x2f91, 0x3985, 0x32a0, 0x3ad3, 0x332a, 0x2c75, 0x2c0f, 0x3544, 0x168e, 0x36fd, 0x3308, + 0x2d59, 0x3b64, 0x3844, 0x3a0a, 0x392f, 0x3a96, 0x30ed, 0x38d1, 0x3147, 0x3ad1, 0x3962, 0x3432, + 0x3033, 0x36bf, 0x3b25, 0x3bdd, 0x3bea, 0x39a0, 0x38c9, 0x3b33, 0x2c08, 0x394a, 0x3bf5, 0x3910, + 0x317b, 0x3b34, 0x3aa4, 0x3af1, 0x3abf, 0x3b98, 0x3bb1, 0x3621, 0x3ac2, 0x38f3, 0x3b91, 0x3378, + 0x3763, 0x3b95, 0x3bad, 0x36b2, 0x3357, 0x384b, 0x395a, 0x3bab, 0x3024, 0x3ae5, 0x35b0, 0x31b3, + 0x3421, 0x3a39, 0x34db, 0x38a1, 0x301e, 0x3587, 0x32f6, 0x342c, 0x3a95, 0x3726, 0x3719, 0x2cd2, + 0x3a28, 0x399d, 0x388d, 0x39a0, 0x3abb, 0x3b3a, 0x2828, 0x39fb, 0x2f0a, 0x3931, 0x384c, 0x36a8, + 0x3411, 0x3545, 0x2f7d, 0x3854, 0x30d4, 0x3acb, 0x3a73, 0x308f, 0x2010, 0x34df, 0x391f, 0x31f9, + 0x32bd, 0x3a75, 0x381d, 0x3912, 0x394d, 0x3404, 0x38e8, 0x3a5b, 0x3a62, 0x3af0, 0x3a17, 0x39a3, + 0x341a, 0x3332, 0x37cc, 0x3b2b, 0x367c, 0x38b2, 0x3663, 0x3b73, 0x3b2d, 0x3bf0, 0x35a5, 0x363b, + 0x33be, 0x379b, 0x361e, 0x3918, 0x3ad9, 0x2a92, 0x3462, 0x2144, 0x2081, 0x3845, 0x326d, 0x3717, + 0x3831, 0x3958, 0x3893, 0x32b4, 0x3a1e, 0x3aa2, 0x3487, 0x38b2, 0x32a0, 0x3a03, 0x3a70, 0x34c2, + 0x365c, 0x3842, 0x38ad, 0x366f, 0x3a07, 0x37da, 0x30f2, 0x374d, 0x3a41, 0x3a7e, 0x33a9, 0x3166, + 0x37d5, 0x3808, 0x3b70, 0x39b9, 0x3969, 0x3681, 0x2f53, 0x35b5, 0x31dc, 0x3bc2, 0x38b6, 0x2f39, + 0x3999, 0x3b31, 0x331e, 0x388c, 0x3b5a, 0x39db, 0x3aaa, 0x39dd, 0x34d9, 0x34a4, 0x2f6a, 0x3822, + 0x3a3f, 0x3ac5, 0x3a1c, 0x3518, 0x3337, 0x295b, 0x3b0e, 0x3af2, 0x3987, 0x20c4, 0x394c, 0x34e6, + 0x380a, 0x3502, 0x1b82, 0x2c8a, 0x3425, 0x378a, 0x3bc8, 0x30c5, 0x391d, 0x34f8, 0x3af9, 0x3908, + 0x38e0, 0x3bee, 0x3b38, 0x3a0b, 0x36ea, 0x2de6, 0x360d, 0x35bc, 0x395a, 0x3b3e, 0x3808, 0x38ef, + 0x3804, 0x393f, 0x39af, 0x32d9, 0x3bc0, 0x39de, 0x330d, 0x383e, 0x3a63, 0x2c2e, 0x2f9c, 0x3308, + 0x397c, 0x3aed, 0x3ad6, 0x336d, 0x3309, 0x2a59, 0x3a35, 0x3ab3, 0x3998, 0x3aec, 0x3633, 0x3b63, + 0x3a28, 0x3bbe, 0x34d1, 0x377e, 0x332a, 0x3ae8, 0x3a18, 0x3a44, 0x3932, 0x3576, 0x3bc8, 0x3aef, + 0x3bcb, 0x3898, 0x3916, 0x397e, 0x3332, 0x3b99, 0x38df, 0x38f1, 0x2e04, 0x3a33, 0x35ea, 0x31de, + 0x1f39, 0x3911, 0x33b6, 0x3bb1, 0x3a21, 0x33e4, 0x354a, 0x2f83, 0x389e, 0x3357, 0x343e, 0x3af9, + 0x35fd, 0x3810, 0x39e3, 0x38f6, 0x3632, 0x2e8d, 0x3340, 0x2b4c, 0x3b23, 0x3955, 0x32b4, 0x3670, + 0x3633, 0x3b07, 0x3341, 0x3449, 0x35f2, 0x3ab9, 0x3379, 0x34d9, 0x393a, 0x3b47, 0x3764, 0x3bed, + 0x3755, 0x3581, 0x3a94, 0x3b72, 0x35bb, 0x3ac4, 0x25a2, 0x3a4e, 0x32df, 0x3bf7, 0x3aa7, 0x38ff, + 0x3848, 0x39c2, 0x3b40, 0x3984, 0x3a57, 0x19ab, 0x3b95, 0x1d5e, 0x3811, 0x37dd, 0x38bd, 0x2e92, + 0x3835, 0x3972, 0x372e, 0x2d3a, 0x34a4, 0x3823, 0x3274, 0x31d8, 0x3898, 0x3756, 0x3786, 0x2c2c, + 0x3b95, 0x3aff, 0x3272, 0x3866, 0x3881, 0x319c, 0x38c8, 0x3bbf, 0x33df, 0x3a86, 0x3188, 0x38d3, + 0x38ea, 0x120b, 0x3abd, 0x2e02, 0x387b, 0x3860, 0x2883, 0x3a44, 0x33db, 0x38c8, 0x3be0, 0x3418, + 0x397e, 0x3a52, 0x393b, 0x39f4, 0x3ad3, 0x2a7d, 0x37bd, 0x3af0, 0x3919, 0x3947, 0x3814, 0x37ee, + 0x28fb, 0x387c, 0x36d2, 0x39b5, 0x3319, 0x3498, 0x329c, 0x3831, 0x35d5, 0x2a9e, 0x3a3d, 0x2f8d, + 0x386f, 0x2e3b, 0x329c, 0x38be, 0x3b5a, 0x3a90, 0x33ae, 0x3982, 0x3b62, 0x39ae, 0x39ec, 0x3679, + 0x3734, 0x3a0d, 0x3a24, 0x34ca, 0x38c2, 0x3987, 0x304e, 0x3990, 0x38d8, 0x3b86, 0x3abf, 0x3670, + 0x3a6c, 0x2f99, 0x33a9, 0x3aba, 0x385f, 0x3a37, 0x3a6e, 0x3624, 0x32ff, 0x3a02, 0x33f6, 0x3a0f, + 0x3563, 0x38f4, 0x38ba, 0x267e, 0x296d, 0x35fd, 0x3b89, 0x32bc, 0x3acf, 0x3904, 0x3a51, 0x3431, + 0x2260, 0x388e, 0x37b1, 0x35c3, 0x35f9, 0x2f87, 0x3b05, 0x2799, 0x33f5, 0x2196, 0x3027, 0x34cc, + 0x35d3, 0x3893, 0x312d, 0x34e4, 0x3861, 0x346d, 0x397c, 0x3a08, 0x3637, 0x3086, 0x3481, 0x30ab, + 0x3533, 0x33c6, 0x2d48, 0x3648, 0x359c, 0x390c, 0x3677, 0x354a, 0x3b4d, 0x3b9d, 0x3323, 0x3694, + 0x3213, 0x329d, 0x3828, 0x382d, 0x31bf, 0x3746, 0x3635, 0x3198, 0x3032, 0x3092, 0x303d, 0x397c, + 0x3b01, 0x3ab5, 0x3b7e, 0x29a3, 0x340f, 0x30fb, 0x35cb, 0x3424, 0x39b0, 0x3187, 0x3754, 0x3b8b, + 0x3810, 0x3554, 0x3b1c, 0x3806, 0x3bde, 0x2a39, 0x3aa3, 0x3b27, 0x3b94, 0x3786, 0x3503, 0x388a, + 0x383f, 0x3884, 0x3bf9, 0x3a20, 0x395a, 0x33af, 0x33d9, 0x3b30, 0x3be0, 0x2c91, 0x3b4a, 0x373a, + 0x3beb, 0x3a54, 0x3b5e, 0x3599, 0x3466, 0x3538, 0x35e9, 0x387b, 0x3904, 0x288a, 0x3b05, 0x35a5, + 0x3316, 0x395f, 0x3869, 0x39e4, 0x34ac, 0x350a, 0x2dd8, 0x32c7, 0x32e2, 0x3be7, 0x38f4, 0x3ada, + 0x3959, 0x3a32, 0x3876, 0x3a54, 0x3636, 0x35f4, 0x381d, 0x3931, 0x39fc, 0x3a4d, 0x3591, 0x34c7, + 0x33ad, 0x3ac2, 0x3ada, 0x2b1d, 0x3153, 0x3741, 0x3a10, 0x38fa, 0x32ed, 0x3bcc, 0x31be, 0x3a65, + 0x335c, 0x3a5f, 0x3b18, 0x3711, 0x3ba3, 0x367b, 0x3820, 0x2b7e, 0x3111, 0x3b3f, 0x2591, 0x38cc, + 0x3971, 0x34ac, 0x2d8a, 0x36bb, 0x39b1, 0x37b8, 0x3924, 0x2f50, 0x3597, 0x33b7, 0x2d00, 0x2a92, + 0x3496, 0x385e, 0x3b0a, 0x3b25, 0x3045, 0x2d1a, 0x374d, 0x221c, 0x2b6e, 0x39bb, 0x37c7, 0x387f, + 0x3793, 0x308b, 0x3556, 0x3952, 0x36c2, 0x362a, 0x3bcb, 0x39c9, 0x3a56, 0x2dd3, 0x352a, 0x382b, + 0x2888, 0x3bb2, 0x395d, 0x21e7, 0x372a, 0x3b6f, 0x39ed, 0x3bf7, 0x33b2, 0x3ab1, 0x37de, 0x39b8, + 0x28e5, 0x2ee3, 0x3a48, 0x369b, 0x396c, 0x1974, 0x3563, 0x3821, 0x3967, 0x2e88, 0x35a7, 0x392a, + 0x385a, 0x3b40, 0x2eea, 0x3b24, 0x37aa, 0x31b3, 0x3400, 0x3835, 0x2b2e, 0x2e60, 0x3be0, 0x3367, + 0x3b53, 0x3beb, 0x30a5, 0x3810, 0x3849, 0x37a1, 0x3a03, 0x3962, 0x33b8, 0x37e7, 0x2d24, 0x329c, + 0x3874, 0x3ba1, 0x1e36, 0x3138, 0x3a89, 0x38fc, 0x3b3d, 0x3440, 0x3b76, 0x3b94, 0x373c, 0x2821, + 0x39a5, 0x3800, 0x27ab, 0x3adc, 0x3219, 0x3a16, 0x36d0, 0x3ac8, 0x3b92, 0x3618, 0x38b7, 0x3a27, + 0x3791, 0x3b35, 0x380a, 0x3acf, 0x345c, 0x3ace, 0x376f, 0x384b, 0x3aae, 0x37e4, 0x38c6, 0x2f10, + 0x35b4, 0x3b6b, 0x3afe, 0x32a2, 0x35b4, 0x358d, 0x2859, 0x35a1, 0x33f2, 0x3971, 0x35ec, 0x38a6, + 0x390a, 0x380d, 0x3bed, 0x33f2, 0x3529, 0x3ac4, 0x2e88, 0x30da, 0x3b57, 0x39ad, 0x3bbd, 0x2771, + 0x2eac, 0x39d6, 0x384f, 0x39cc, 0x3868, 0x3b6e, 0x36ea, 0x3001, 0x3568, 0x3b8a, 0x333b, 0x3987, + 0x2672, 0x349e, 0x33fc, 0x38f9, 0x3b7e, 0x3bfc, 0x37a9, 0x3664, 0x3a0e, 0x3bce, 0x37a7, 0x35ad, + 0x3b0c, 0x3a22, 0x3318, 0x3b54, 0x3863, 0x3a66, 0x388c, 0x3b53, 0x396a, 0x3a55, 0x32c7, 0x3a96, + 0x38b3, 0x36d9, 0x3676, 0x36bd, 0x2da9, 0x36c6, 0x3154, 0x372f, 0x396a, 0x3718, 0x31b0, 0x3bb4, + 0x3aae, 0x37a3, 0x3892, 0x364b, 0x32c0, 0x3851, 0x286f, 0x3a6a, 0x3772, 0x3924, 0x2526, 0x3b09, + 0x3025, 0x3951, 0x32e1, 0x3880, 0x38e2, 0x3b44, 0x259d, 0x35ba, 0x3581, 0x300b, 0x3945, 0x3ae1, + 0x3bdf, 0x354f, 0x3825, 0x3b02, 0x3551, 0x39bd, 0x3bb8, 0x38f9, 0x31da, 0x37e9, 0x37e1, 0x3b6d, + 0x39f8, 0x3885, 0x3993, 0x362d, 0x3b55, 0x33ef, 0x3895, 0x394d, 0x2d0b, 0x3702, 0x39bc, 0x3b39, + 0x3036, 0x38aa, 0x3582, 0x3474, 0x3bf6, 0x344f, 0x389d, 0x3bbb, 0x32cd, 0x302b, 0x37f4, 0x38a6, + 0x3854, 0x368c, 0x3ab0, 0x3aff, 0x385d, 0x354c, 0x38bb, 0x2e0f, 0x3b75, 0x36e9, 0x380d, 0x38f9, + 0x386a, 0x36d5, 0x3746, 0x3b00, 0x368a, 0x3961, 0x3673, 0x352a, 0x351b, 0x2aac, 0x3988, 0x3754, + 0x3886, 0x3aec, 0x381e, 0x3832, 0x3ac5, 0x2179, 0x3ba1, 0x3b00, 0x3a55, 0x392e, 0x326b, 0x296d, + 0x25a4, 0x3a74, 0x320e, 0x30e0, 0x317f, 0x3bfd, 0x3bc5, 0x2af4, 0x3b85, 0x3603, 0x3ba8, 0x352a, + 0x38e5, 0x37be, 0x32cc, 0x387e, 0x389f, 0x2ed9, 0x3a27, 0x3174, 0x3b45, 0x3a84, 0x3be2, 0x35f2, + 0x3a49, 0x3aba, 0x34fe, 0x34e8, 0x3ba0, 0x3940, 0x3b98, 0x3b65, 0x3b95, 0x3735, 0x3b3c, 0x3801, + 0x3a86, 0x39a0, 0x3ba1, 0x360f, 0x2b45, 0x3806, 0x35e7, 0x3b4a, 0x3a83, 0x39d3, 0x31c7, 0x3088, + 0x38b6, 0x3aa2, 0x3b80, 0x366e, 0x3a81, 0x3836, 0x330e, 0x3ac2, 0x3a13, 0x3a60, 0x37c2, 0x369d, + 0x3a8a, 0x3778, 0x3322, 0x2c22, 0x3ae9, 0x38fd, 0x3b37, 0x23c0, 0x30ba, 0x2e6a, 0x397a, 0x3166, + 0x3a2e, 0x2fc5, 0x2b07, 0x36f2, 0x36b4, 0x3b63, 0x3ba7, 0x3641, 0x2c50, 0x38f4, 0x3857, 0x3a1d, + 0x378f, 0x38da, 0x2a45, 0x3849, 0x2ae1, 0x3ad9, 0x2e87, 0x3adb, 0x8f4, 0x20ef, 0x3aba, 0x3a2d, + 0x340b, 0x3bab, 0x352d, 0x3941, 0x3ac3, 0x3a8d, 0x362a, 0x3a02, 0x3a49, 0x2d45, 0x334a, 0x2bfc, + 0x35a1, 0x304a, 0x3666, 0x35c0, 0x3838, 0x3a55, 0x3656, 0x34f6, 0x341a, 0x3879, 0x368a, 0x3744, + 0x3886, 0x3320, 0x3459, 0x38d4, 0x30ae, 0x3815, 0x3568, 0x3101, 0x3455, 0x3727, 0x39a9, 0x37e6, + 0x3259, 0x3bb1, 0x3781, 0x3a91, 0x3998, 0x2d2f, 0x32d8, 0x3955, 0x3844, 0x2753, 0x3bf4, 0x340e, + 0x3a49, 0x397b, 0x39e1, 0x3992, 0x38b5, 0x34e6, 0x3741, 0x3113, 0x3a5d, 0x395d, 0x38eb, 0x3542, + 0x3b17, 0x38c7, 0x3564, 0x350d, 0x3846, 0x384c, 0x338c, 0x39fe, 0x2dc8, 0x3ac8, 0x2fee, 0x3b1e, + 0x378c, 0x3455, 0x35b3, 0x38cd, 0x3950, 0x3b98, 0x2b96, 0x3aca, 0x3809, 0x37c9, 0x393e, 0x39f8, + 0x3822, 0x3187, 0x3905, 0x3bdb, 0x360c, 0x34d7, 0x3408, 0x38e3, 0x358e, 0x3a58, 0x33cf, 0x38d2, + 0x3a8f, 0x389c, 0x3a45, 0x325b, 0x2a6c, 0x375f, 0x3382, 0x3a44, 0x3256, 0x2770, 0x3bd6, 0x2f05, + 0x34cf, 0x29d7, 0x2d77, 0x38b9, 0x3971, 0x3518, 0x2e1b, 0x39dc, 0x31d4, 0x388a, 0x3b6d, 0x37a7, + 0x28c3, 0x3720, 0x3050, 0x38fd, 0x3801, 0x3b4b, 0x3308, 0x38a1, 0x3241, 0x3184, 0x39b8, 0x3bef, + 0x2930, 0x395b, 0x3a49, 0x39d2, 0x3b2d, 0x2e75, 0x2cc6, 0x3b5e, 0x3724, 0x3352, 0x31fc, 0x3607, + 0x3ae9, 0x3867, 0x3a8c, 0x24ab, 0x3821, 0x328e, 0x2f81, 0x249f, 0x2d6f, 0x352d, 0x3723, 0x37b2, + 0x3683, 0x36f4, 0x3a8c, 0x38fb, 0x3a36, 0x3ad9, 0x38b6, 0x3522, 0x38b7, 0x30f8, 0x36ee, 0x3a71, + 0x36fd, 0x349b, 0x3343, 0x36ae, 0x3895, 0x365a, 0x3bf5, 0x3a04, 0x3931, 0x36fa, 0x3970, 0x39fb, + 0x2c7a, 0x3a47, 0x3987, 0x3429, 0x338f, 0x3ba1, 0x393e, 0x3a05, 0x3a0d, 0x2e16, 0x34c9, 0x3943, + 0x302a, 0x31e9, 0x3401, 0x330a, 0x3bc4, 0x3542, 0x38fc, 0x38bb, 0x3401, 0x37be, 0x371f, 0x3933, + 0x3963, 0x385f, 0x3479, 0x3bff, 0x2c2b, 0x3782, 0x2cda, 0x396b, 0x3a8c, 0x3bf9, 0x34b0, 0x3696, + 0x3a9f, 0x33a1, 0x322f, 0x396b, 0x3be3, 0x3ade, 0x381c, 0x3a76, 0x388c, 0x2896, 0x2724, 0x39d7, + 0x35a4, 0x37b3, 0x3282, 0x272c, 0x3774, 0x247f, 0x3bed, 0x1989, 0x3b14, 0x3861, 0x3b1d, 0x3909, + 0x23a3, 0x3ae8, 0x399c, 0x3b39, 0x3b6a, 0x3a49, 0x3454, 0x3b04, 0x3a85, 0x3b06, 0x2fe7, 0x32d7, + 0x3879, 0x3b8e, 0x33ed, 0x38a8, 0x359e, 0x39f7, 0x3546, 0x31f7, 0x3bc7, 0x3387, 0x3279, 0x39af, + 0x39e2, 0x3432, 0x37c3, 0x3b4a, 0x3b34, 0x3b66, 0x23fc, 0x3a1a, 0x3577, 0x35b1, 0x3a02, 0x2584, + 0x36be, 0x3389, 0x3bcc, 0x369c, 0x38a5, 0x381f, 0x3553, 0x39ab, 0x3a9a, 0x395c, 0x381f, 0x3b60, + 0x36d8, 0x342a, 0x344e, 0x30f8, 0x3a5e, 0x34e7, 0x35b1, 0x3739, 0x3838, 0x32d9, 0x38ac, 0x386a, + 0x39ae, 0x1826, 0x2431, 0x38ea, 0x3b66, 0x3b9e, 0x3b3c, 0x3b1d, 0x38cb, 0x3537, 0x391b, 0x364c, + 0x3aa0, 0x2f83, 0x289d, 0x35da, 0x3a40, 0x3527, 0x386e, 0x2d5e, 0x3a81, 0x36a6, 0x32af, 0x357e, + 0x375c, 0x33ca, 0x3837, 0x2dae, 0x3595, 0x2912, 0x349a, 0x353a, 0x35db, 0x3b28, 0x3978, 0x3470, + 0x30ae, 0x3a15, 0x38bb, 0x3b82, 0x388c, 0x3778, 0x34fb, 0x3b0e, 0x3b13, 0x3b9c, 0x303b, 0x14ea, + 0x2feb, 0x3660, 0x33ea, 0x3b08, 0x3a7f, 0x292f, 0x3be3, 0x372b, 0x39e9, 0x3b26, 0x3725, 0x34f1, + 0x3a2a, 0x38cc, 0x3a67, 0x3819, 0x3ba5, 0x339b, 0x3bf6, 0x3420, 0x3548, 0x38e5, 0x39e3, 0x3a62, + 0x35e3, 0x3a03, 0x3893, 0x39c2, 0x3848, 0x38fa, 0x396c, 0x32a7, 0x3a8f, 0x329b, 0x32f1, 0x39d3, + 0x1a9c, 0x3aea, 0x3782, 0x38f2, 0x3829, 0x2e91, 0x39fc, 0x3716, 0x3899, 0x31bb, 0x349b, 0x32eb, + 0x367e, 0x3bad, 0x38f1, 0x34cc, 0x35dd, 0x31ba, 0x3ad9, 0x1dc5, 0x3884, 0x2c64, 0x2ec7, 0x35ed, + 0x2e64, 0x3a4a, 0x38b5, 0x3b59, 0x2c80, 0x318b, 0x2d35, 0x38d9, 0x3a09, 0x31c2, 0x37be, 0x39f4, + 0x3435, 0x3994, 0x39dc, 0x3933, 0x3035, 0x3984, 0x3228, 0x2d01, 0x3940, 0x3bd3, 0x385d, 0x2e62, + 0x3643, 0x3b0c, 0x3454, 0x3686, 0x3b52, 0x3b5b, 0x3ac5, 0x3998, 0x307b, 0x38d5, 0x36e4, 0x341f, + 0x39e7, 0x3a62, 0x34c5, 0x39b5, 0x37b6, 0x37b4, 0x3868, 0x3888, 0x38b9, 0x37e1, 0x36a5, 0x386c, + 0x39d8, 0x3961, 0x3ba9, 0x38a1, 0x2ca0, 0x38b3, 0x3aea, 0x352d, 0x33f9, 0x3808, 0x37b6, 0x3a39, + 0x3aba, 0x3799, 0x36fe, 0x34fd, 0x374f, 0x34eb, 0x3720, 0x3466, 0x39ff, 0x3922, 0x3113, 0x3a13, + 0x3bb0, 0x3ac9, 0x3879, 0x2a5c, 0x26e4, 0x37cc, 0x39a0, 0x353a, 0x3688, 0x3ac1, 0x3bee, 0x3a3e, + 0x3949, 0x38f5, 0x307a, 0x2e5b, 0x3531, 0x382f, 0x338a, 0x3ac2, 0x3966, 0x34e2, 0x2f1b, 0x3a1d, + 0x3686, 0x38e3, 0x322d, 0x351c, 0x3b01, 0x360c, 0x33c8, 0x35e4, 0x2cea, 0x3642, 0x39b7, 0x37fa, + 0x3102, 0x2f06, 0x33ce, 0x365a, 0x335a, 0x3550, 0x2b84, 0x38dc, 0x3aaf, 0x39fb, 0x39e0, 0x32e2, + 0x33f5, 0x3a5e, 0x3bdb, 0x2963, 0x3229, 0x3b41, 0x3783, 0x3a11, 0x382c, 0x3952, 0x37a0, 0x38c5, + 0x2894, 0x3325, 0x3468, 0x3029, 0x3719, 0x38ad, 0x357e, 0x2ee3, 0x2d33, 0x3445, 0x3ac4, 0x3108, + 0x398f, 0x35e7, 0x384b, 0x3870, 0x387d, 0x3235, 0x397c, 0x3891, 0x38bc, 0x28df, 0x388c, 0x3974, + 0x34cd, 0x3a34, 0x3861, 0x3bf8, 0x3934, 0x364a, 0x3644, 0x3af6, 0x3742, 0x398b, 0x3a7c, 0x3bb8, + 0x33fe, 0x397b, 0x3bae, 0x3b83, 0x360e, 0x35b9, 0x39a4, 0x3a32, 0x38d9, 0x304f, 0x38c1, 0x297f, + 0x3b47, 0x3a0f, 0x3b27, 0x3bdf, 0x35a6, 0x39a0, 0x31b1, 0x389d, 0x3745, 0x3b82, 0x37b2, 0x3945, + 0x36b9, 0x398b, 0x35c2, 0x3335, 0x30f6, 0x30f3, 0x35c9, 0x38b4, 0x3833, 0x3601, 0x321c, 0x350c, + 0x36e7, 0x3452, 0x2f4f, 0x2b8e, 0x3a7c, 0x311b, 0x3b93, 0x3bd3, 0x3b75, 0x3711, 0x34dc, 0x380f, + 0x39f7, 0x2b7b, 0x31de, 0x9f0, 0x3783, 0x331c, 0x3b71, 0x21bc, 0x3a5e, 0x38ed, 0x39db, 0x309e, + 0x3565, 0x382d, 0x3682, 0x3b3e, 0x3b3b, 0x3419, 0x35e2, 0x3a64, 0x3be9, 0x335e, 0x377e, 0x3a3a, + 0x3b74, 0x3688, 0x3a52, 0x322c, 0x3a83, 0x3a51, 0x3afb, 0x38e5, 0x3bde, 0x3afe, 0x3917, 0x37f7, + 0x283d, 0x3b60, 0x3408, 0x3543, 0x38ce, 0x38fe, 0x3b49, 0x2e7d, 0x3a16, 0x3920, 0x28c9, 0x34d5, + 0x3be4, 0x2e71, 0x3ace, 0x3aa0, 0x3ac0, 0x3618, 0x3b1a, 0x29fa, 0x3962, 0x358d, 0x2f85, 0x3ad2, + 0x3198, 0x373d, 0x3b9e, 0x362d, 0x381e, 0x3ad3, 0x3904, 0x18b4, 0x37c3, 0x386b, 0x3982, 0x3711, + 0x3a56, 0x3ac7, 0x38c2, 0x2d57, 0x313b, 0x31fd, 0x3423, 0x35a4, 0x38be, 0x3857, 0x36b9, 0x3b9d, + 0x39de, 0x33e8, 0x3896, 0x3919, 0x32ee, 0x3b94, 0x3528, 0x38fc, 0x38ca, 0x25e6, 0x38ca, 0x396f, + 0x3a63, 0x2a52, 0x3a30, 0x393f, 0x38f1, 0x3a58, 0x3537, 0x3295, 0x38ec, 0x391b, 0x3839, 0x3448, + 0x39db, 0x34fa, 0x37db, 0x3bf0, 0x396e, 0x353f, 0x3474, 0x1958, 0x3964, 0x3958, 0x36d3, 0x3966, + 0x3a4d, 0x3132, 0x3a83, 0x31b7, 0x272b, 0x38e1, 0x300d, 0x3afe, 0x2a0c, 0x31f3, 0x377f, 0x384a, + 0x2925, 0x38ce, 0x3a89, 0x3bdf, 0x36ef, 0x3219, 0x2e91, 0x3651, 0x3875, 0x30a4, 0x3a9e, 0x3b89, + 0x3150, 0x34e5, 0x3a6c, 0x36d0, 0x32af, 0x34b9, 0x3b92, 0x3b54, 0x3b42, 0x3a63, 0x3a4e, 0x36ef, + 0x3ba1, 0x389e, 0x307a, 0x34e9, 0x3a92, 0x353b, 0x3905, 0x39a6, 0x3838, 0x3135, 0x3501, 0x39b2, + 0x3ae9, 0x325a, 0x3173, 0x329c, 0x385b, 0x3830, 0x31f8, 0x3819, 0x3b5b, 0x3a59, 0x3b28, 0x3a12, + 0x3afd, 0x37b4, 0x383d, 0x39ba, 0x3b68, 0x3b3c, 0x3b38, 0x31d1, 0x3566, 0x36f0, 0x387e, 0x354d, + 0x330b, 0x3aba, 0x3323, 0x3a7d, 0x369c, 0x29c1, 0x3b29, 0x38a8, 0x3a08, 0x323d, 0x3b93, 0x3833, + 0x3284, 0x39b4, 0x386e, 0x3840, 0x39fc, 0x3365, 0x29a9, 0x379c, 0x3648, 0x31df, 0x3b00, 0x31d7, + 0x3b0e, 0x33b0, 0x3bfe, 0x3bfb, 0x33b2, 0x2d56, 0x3361, 0x3ba6, 0x3bd0, 0x395b, 0x360c, 0x344e, + 0x3bde, 0x3bdb, 0x3afb, 0x328d, 0x2f81, 0x3b0c, 0x3ba8, 0x362f, 0x3301, 0x3740, 0x36e4, 0x39d1, + 0x34ee, 0x37ed, 0x36c7, 0x32b3, 0x36e3, 0x34dc, 0x35ee, 0x3b00, 0x2ec8, 0x3aa9, 0x3bac, 0x35ae, + 0x38db, 0x345b, 0x2dfe, 0x2c7c, 0x3b56, 0x2cf5, 0x3130, 0x3b7e, 0x38bc, 0x39d6, 0x38d1, 0x3b91, + 0x3749, 0x34bb, 0x3a3f, 0x34e5, 0x370a, 0x351d, 0x35d4, 0x300b, 0x3a3f, 0x3867, 0x35d8, 0x32b3, + 0x38c9, 0x3962, 0x2c72, 0x3990, 0x1bc9, 0x35b2, 0x3077, 0x37bc, 0x3a42, 0x3b14, 0x2e52, 0x38ec, + 0x3b5e, 0x35c8, 0x3bb4, 0x36a4, 0x3812, 0x344f, 0x378b, 0x348c, 0x3a47, 0x3afb, 0x3981, 0x3b82, + 0x3b3c, 0x3296, 0x376f, 0x3196, 0x37d6, 0x353a, 0x3924, 0x38cc, 0x3220, 0x3b67, 0x2e21, 0x35fb, + 0x3790, 0x2a9e, 0x32e4, 0x394b, 0x38ca, 0x34cc, 0x395b, 0x3411, 0x3a7f, 0x37a9, 0x3116, 0x3460, + 0x346b, 0x380e, 0x394d, 0x3afd, 0x2d46, 0x3413, 0x3924, 0x3abf, 0x28d2, 0x3b03, 0x3493, 0x354b, + 0x2a7a, 0x3aea, 0x3618, 0x3708, 0x3b07, 0x394c, 0x3a64, 0x3be7, 0x36be, 0x3bf5, 0x37a4, 0x3a9f, + 0x399c, 0x30b7, 0x3976, 0x3b70, 0x3bad, 0x3b7e, 0x3b6d, 0x3662, 0x31fc, 0x3bae, 0x361f, 0x3878, + 0x3b22, 0x3849, 0x3446, 0x3be2, 0x3bff, 0x37f3, 0x31b5, 0x30b9, 0x399f, 0x35a0, 0x3915, 0x3668, + 0x2b35, 0x2b76, 0x3886, 0x3935, 0x38da, 0x3836, 0x2711, 0x32f8, 0x38eb, 0x3481, 0x3243, 0x2d33, + 0x3b0f, 0x36ba, 0x393f, 0x35b7, 0x3685, 0x3a15, 0x333a, 0x3afe, 0x2863, 0x3b5b, 0x3a94, 0x39cd, + 0x3ad6, 0x3ac1, 0x3b72, 0x3423, 0x32f1, 0x2c93, 0x3141, 0x3462, 0x3bd9, 0x3b8b, 0x2451, 0x3071, + 0x3bd1, 0x3512, 0x372a, 0x38ce, 0x3892, 0x35cd, 0x388c, 0x3456, 0x2cb2, 0x26c2, 0x2df1, 0x38f2, + 0x3427, 0x2cad, 0x34b5, 0x3285, 0x2e33, 0x31c7, 0x3948, 0x3634, 0x35b8, 0x3478, 0x375b, 0x38fb, + 0x3769, 0x390b, 0x3880, 0x309e, 0x33bc, 0x3b8e, 0x3311, 0x3489, 0x29ff, 0x34ef, 0x3af6, 0x3ab2, + 0x31b5, 0x398e, 0x3857, 0x2886, 0x3847, 0x3bd9, 0x37fc, 0x393c, 0x2c6d, 0x30df, 0x2e7b, 0x340e, + 0x3bae, 0x3b5e, 0x38d1, 0x37b7, 0x3ab7, 0x356d, 0x3528, 0x2c58, 0x38db, 0x3951, 0x30c1, 0x394e, + 0x3395, 0x3273, 0x329c, 0x3882, 0x2f1b, 0x3a6d, 0x3a2d, 0x3bdb, 0x3850, 0x3a43, 0x35ba, 0x3884, + 0x3197, 0x2d5e, 0x3b30, 0x3393, 0x39c9, 0x3aa0, 0x2c7d, 0x2d28, 0x3776, 0x35ca, 0x34d1, 0x38f3, + 0x327e, 0x3a71, 0x3a4f, 0x36bf, 0x30c3, 0x388e, 0x38d2, 0x2a3b, 0x2de6, 0x363d, 0x3adc, 0x3b64, + 0x2889, 0x2e46, 0x3570, 0x3b46, 0x3549, 0x3b6c, 0x3afc, 0x3b07, 0x3bde, 0x35e3, 0x39d7, 0x3b0e, + 0x303f, 0x2068, 0x37d4, 0x3bc9, 0x2d84, 0x367c, 0x3adb, 0x364f, 0x244b, 0x36fb, 0x3829, 0x34cc, + 0x3aa4, 0x3507, 0x366e, 0x3333, 0x34b7, 0x3a84, 0x37db, 0x3a35, 0x26fe, 0x346a, 0x3b25, 0x37b7, + 0x3a1f, 0x399d, 0x2c52, 0x3b8d, 0x3501, 0x3ac0, 0x3a06, 0x3af9, 0x36f8, 0x312c, 0x3990, 0x3af5, + 0x3a91, 0x2db0, 0x39cc, 0x3221, 0x21d5, 0x36f2, 0x20c8, 0x3245, 0x399f, 0x2ed7, 0x39ea, 0x2c2f, + 0x2e81, 0x3b28, 0x333b, 0x3a13, 0x357b, 0x387a, 0x34f2, 0x28d2, 0x33b8, 0x39e8, 0x38cc, 0x398d, + 0x3258, 0x39fc, 0x31ab, 0x3883, 0x350a, 0x32f9, 0x3147, 0x395a, 0x3b60, 0x3a31, 0x2315, 0x2d1e, + 0x37ab, 0x3b16, 0x3421, 0x35f0, 0x302d, 0x3ac8, 0x3955, 0x353b, 0x35ba, 0x3716, 0x3411, 0x2a1b, + 0x35d2, 0x2d64, 0x3914, 0x3b78, 0x3438, 0x3791, 0x3b1f, 0x3813, 0x23f6, 0x3456, 0x36e6, 0x2716, + 0x3afd, 0x31a8, 0x3495, 0x3389, 0x3a03, 0x3092, 0x3bf2, 0x3ae4, 0x2459, 0x3891, 0x395e, 0x2f91, + 0x3b3a, 0x219a, 0x2846, 0x3ac4, 0x3921, 0x38cd, 0x35ca, 0x353f, 0x3939, 0x38ec, 0x36e4, 0x2df9, + 0x387b, 0x398b, 0x2de2, 0x391a, 0x36d2, 0x38bd, 0x37c2, 0x361b, 0x3b55, 0x385e, 0x3606, 0x3ae3, + 0x387e, 0x3349, 0x3639, 0x35e3, 0x3073, 0x39e8, 0x3563, 0x3ab8, 0x3880, 0x3648, 0x39ca, 0x3975, + 0x3108, 0x2d94, 0x2f4d, 0x3be2, 0x2bb3, 0x3839, 0x3bdf, 0x3977, 0x3674, 0x3902, 0x3b1d, 0x3a40, + 0x3524, 0x3be8, 0x3afa, 0x356b, 0x31e6, 0x3a0d, 0x3bb2, 0x3b82, 0x3b6b, 0x3672, 0x3626, 0x3b29, + 0x32ed, 0x3961, 0x392e, 0x38a7, 0x2adc, 0x3114, 0x364a, 0x34cd, 0x302d, 0x35db, 0x336d, 0x31a2, + 0x3a14, 0x3102, 0x21ad, 0x326c, 0x345d, 0x3885, 0x383d, 0x3bfd, 0x39a1, 0x37e3, 0x390c, 0x3903, + 0x3b10, 0x34a2, 0x3312, 0x3b64, 0x3b64, 0x389d, 0x301e, 0x3b4c, 0x3971, 0x3a90, 0x3bd1, 0x38c5, + 0x390b, 0x3819, 0x371a, 0x39ae, 0x3b1e, 0x393b, 0x378b, 0x3bd8, 0x3884, 0x370d, 0x3a16, 0x365f, + 0x3102, 0x382e, 0x3415, 0x39bb, 0x39fb, 0x38c1, 0x37fe, 0x390e, 0x3a18, 0x1900, 0x3828, 0x3a0d, + 0x301c, 0x3927, 0x3a15, 0x38d8, 0x36cb, 0x2b55, 0x336b, 0x3b0f, 0x3851, 0x37e9, 0x2dfa, 0x3aac, + 0x3baa, 0x39af, 0x38c6, 0x392e, 0x364d, 0x3ab4, 0x247c, 0x3a0d, 0x3a7a, 0x39d1, 0x37fc, 0x370a, + 0x351d, 0x392a, 0x351a, 0x3671, 0x3a9d, 0x2cd1, 0x3b16, 0x3b02, 0x1921, 0x39b2, 0x3afe, 0x35eb, + 0x301d, 0x38cc, 0x3a67, 0x3986, 0x32fb, 0x3a9b, 0x3a10, 0x3a1a, 0x288d, 0x3afa, 0x3269, 0x3be1, + 0x3822, 0x3923, 0x351a, 0x24a4, 0x3519, 0x3717, 0x383f, 0x3b3e, 0x39d0, 0x352e, 0x394a, 0x3532, + 0x39fd, 0x39ae, 0x3818, 0x3aec, 0x3bfb, 0x267e, 0x2caf, 0x3b8b, 0x3432, 0x2dca, 0x3afa, 0x36b0}; + +uint16_t y_inp[M_SIZE * K_SIZE] = { + 0x334e, 0x3a40, 0x2629, 0x320a, 0x30f1, 0x3b24, 0x2515, 0x39b7, 0x3053, 0x3709, 0x38c6, 0x36d7, + 0x32be, 0x393f, 0x335d, 0x3aed, 0x3881, 0x3a02, 0x3ac7, 0x35a7, 0x2fdc, 0x334a, 0x3870, 0x38f1, + 0x2abf, 0x3b69, 0x3a4d, 0x3425, 0x3a5d, 0x3717, 0x387a, 0x3858, 0x39f8, 0x3619, 0x352f, 0x3b8d, + 0x347b, 0x3637, 0x3188, 0x3382, 0x340f, 0x3181, 0x31d3, 0x390a, 0x32b7, 0x3bd3, 0x382b, 0x3ba7, + 0x2cde, 0x3ab9, 0x3911, 0x3bef, 0x3677, 0x165b, 0x2d24, 0x3779, 0x3928, 0x213b, 0x3868, 0x3adc, + 0x38de, 0x3a9c, 0x3a9e, 0x3858, 0x38c8, 0x3663, 0x2c0c, 0x3521, 0x3a22, 0x3bd0, 0x3908, 0x35af, + 0x32e6, 0x3acf, 0x387a, 0x3865, 0x2c43, 0x3839, 0x33ab, 0x3a62, 0x3548, 0x383e, 0x3a12, 0x357b, + 0x3b9e, 0x3823, 0x3825, 0x397b, 0x3bcf, 0x31e4, 0x3799, 0x32ad, 0x28d9, 0x3acc, 0x35cb, 0x35b7, + 0x3a80, 0x3b70, 0x3475, 0x3b8a, 0x357d, 0x37d2, 0x2fb4, 0x301f, 0x3b15, 0x3a15, 0x34bd, 0x3abf, + 0x38db, 0x2b71, 0x3a4a, 0x39d5, 0x3a16, 0x25d9, 0x3bb6, 0x3bf5, 0x38b4, 0x34cf, 0x383c, 0x306d, + 0x37ec, 0x31a9, 0x3984, 0x37a3, 0x3440, 0x36a1, 0x3675, 0x2f08, 0x38b9, 0x2b09, 0x2c59, 0x3a99, + 0x3068, 0x3501, 0x3b17, 0x3798, 0x38f2, 0x2c7f, 0x347f, 0x38a4, 0x321e, 0x39e9, 0x375c, 0x38db, + 0x38d5, 0x3b65, 0x3863, 0x3712, 0x3976, 0x3090, 0x3944, 0x3b0c, 0x3b71, 0x23e1, 0x3985, 0x36cd, + 0x3845, 0x39ea, 0x369e, 0x39a5, 0x388e, 0x36a0, 0x34fa, 0x2c23, 0x30d1, 0x3993, 0x38fb, 0x3b4c, + 0x283d, 0x3423, 0x3009, 0x34b2, 0x38ee, 0x36ad, 0x3056, 0x22a0, 0x354e, 0x3aca, 0x324c, 0x38ac, + 0x395d, 0x3058, 0x3b0e, 0x3b1b, 0x3a24, 0x36e2, 0x24b3, 0x39e9, 0x2ed6, 0x3834, 0x31d0, 0x3862, + 0x348f, 0x340d, 0x368f, 0x3b2e, 0x3b48, 0x3579, 0x3029, 0x30ef, 0x3567, 0x2324, 0x2b48, 0x30b1, + 0x33e9, 0x3730, 0x3bf5, 0x29c8, 0x3678, 0x317e, 0x3855, 0x3b26, 0x3499, 0x3529, 0x3108, 0x344a, + 0x39d5, 0x3774, 0x3a36, 0x3b92, 0x34db, 0x3b7d, 0x3721, 0x37aa, 0x3726, 0x3b80, 0x35fa, 0x233e, + 0x39f6, 0x3830, 0x35d3, 0x2232, 0x36c6, 0x3a20, 0x3670, 0x3bb9, 0x3bc0, 0x3951, 0x3a8c, 0x39f7, + 0x391b, 0x39e8, 0x2b8b, 0x329a, 0x3afa, 0x33a6, 0x3397, 0x31a5, 0x3bf3, 0x3865, 0x37ed, 0x3483, + 0x3bc7, 0x3842, 0x2698, 0x3b2a, 0x35ac, 0x3bbd, 0x382a, 0x3824, 0x2ace, 0x38f7, 0x3b95, 0x34c0, + 0x2d14, 0x3415, 0x3830, 0x3aca, 0x351b, 0x3819, 0x3404, 0x3965, 0x3314, 0x3818, 0x2c73, 0x3558, + 0x3bc3, 0x2ea2, 0x3b57, 0x372c, 0x3a3d, 0x3428, 0x388d, 0x3509, 0x3b5d, 0x399e, 0x3885, 0x36f2, + 0x328e, 0x2c6c, 0x2a8c, 0x35b1, 0x3b18, 0x3700, 0x30ea, 0x36ae, 0x38f3, 0x3b2a, 0x30d9, 0x391b, + 0x3812, 0x343e, 0x1434, 0x3a9d, 0x3bf5, 0x3b23, 0x3835, 0x397c, 0x3a04, 0x2c37, 0x2f18, 0x3a39, + 0x371a, 0x3801, 0x246c, 0x33b6, 0x3803, 0x3a43, 0x38ee, 0x3a91, 0x39b1, 0x39d3, 0x2ef3, 0x36ed, + 0x36ad, 0x38a6, 0x34ed, 0x2f88, 0x35f7, 0x3bda, 0x34de, 0x38c4, 0x36f1, 0x345d, 0x39ee, 0x3b02, + 0x3b26, 0x3482, 0x2ec3, 0x3adf, 0x397d, 0x35da, 0x3828, 0x3a9a, 0x3364, 0x342c, 0x3acd, 0x2d11, + 0x3907, 0x3645, 0x3a32, 0x39cf, 0x34a6, 0x38f6, 0x2b4f, 0x3a7a, 0x2e80, 0x3419, 0x340e, 0x28ce, + 0x3b53, 0x353b, 0x39e8, 0x38b3, 0x35fd, 0x3b71, 0x3b10, 0x3ada, 0x3a06, 0x3bf0, 0x3a68, 0x374c, + 0x3a28, 0x3847, 0x3992, 0x3375, 0x37e7, 0x2fc5, 0x3399, 0x3522, 0x3108, 0x36a3, 0x3955, 0x354d, + 0x3a8f, 0x3ba8, 0x3a74, 0x386b, 0x39a7, 0x31a9, 0x34ca, 0x366f, 0x356d, 0x3a3b, 0x3676, 0x371c, + 0x34f2, 0x36cf, 0x26bc, 0x199c, 0x35bd, 0x3ac9, 0x3919, 0x3392, 0x3bf6, 0x39d7, 0x395f, 0x22dd, + 0x3a6f, 0x3095, 0x3a1a, 0x31c2, 0x31ae, 0x39cd, 0x3a7d, 0x3460, 0x3b65, 0x3b10, 0x3b04, 0x396a, + 0x39b5, 0x31d6, 0x3add, 0x3758, 0x35e6, 0x386c, 0x3a99, 0x3bad, 0x24f0, 0x3153, 0x36b3, 0x39cf, + 0x3788, 0x3962, 0x3acb, 0x301b, 0x354a, 0x32ec, 0x3894, 0x3bba, 0x382b, 0x358f, 0x3a59, 0x2ec1, + 0x38ed, 0x37a8, 0x37e3, 0x3a02, 0x3aa7, 0x33ae, 0x3977, 0x3555, 0x36f4, 0x39f8, 0x381e, 0x2f6d, + 0x3213, 0x30d1, 0x2d0a, 0x311d, 0x3812, 0x3037, 0x35c3, 0x3233, 0x336d, 0x2d4c, 0x3022, 0x3909, + 0x354d, 0x3a58, 0x37c4, 0x3b92, 0x2e0d, 0x3a25, 0x3871, 0x3674, 0x3b5e, 0x3420, 0x312c, 0x34a5, + 0x3a7f, 0x3324, 0x39c5, 0x3904, 0x1dee, 0x39de, 0x3029, 0x32da, 0x38f9, 0x353c, 0x35c4, 0x3b3c, + 0x3a68, 0x3508, 0x35a6, 0x302f, 0x2806, 0x3b7f, 0x3895, 0x3b3f, 0x359c, 0x3b0c, 0x378c, 0x3424, + 0x38b7, 0x2b8d, 0x3b35, 0x37c5, 0x32fa, 0x3aa5, 0x3a7b, 0x2e21, 0x3922, 0x36dc, 0x36d3, 0x3b8b, + 0x3a90, 0x36c5, 0x3872, 0x3813, 0x396a, 0x3027, 0x3195, 0x3782, 0x3217, 0x3a01, 0x3bd9, 0x39cf, + 0x3bea, 0x381e, 0x30e9, 0x392d, 0x3129, 0x3a83, 0x38b6, 0x38d8, 0x36fc, 0x39b8, 0x2cc5, 0x3b9a, + 0x370c, 0x39aa, 0x2e32, 0x3a80, 0x38ea, 0x3649, 0x32bd, 0x3844, 0x3828, 0x2e94, 0x382b, 0x353a, + 0x3bb9, 0x3a39, 0x3a61, 0x3b5a, 0x33b9, 0x35a9, 0x3a79, 0x377a, 0x3969, 0x35cb, 0x3483, 0x3b0c, + 0x3b53, 0x3461, 0x3ae6, 0x381a, 0x3bc5, 0x35d0, 0x3b0d, 0x39de, 0x384c, 0x3b82, 0x3190, 0x36df, + 0x2e64, 0x3588, 0x38f2, 0x35ec, 0x3085, 0x311b, 0x3b20, 0x3b46, 0x36b6, 0x381e, 0x3ba3, 0x3335, + 0x3b5d, 0x3b7c, 0x3b06, 0x356d, 0x386c, 0x2d8c, 0x3bcd, 0x3024, 0x2906, 0x2dd1, 0x33b4, 0x3683, + 0x1e9d, 0x39c9, 0x3b4e, 0x3976, 0x3b6c, 0x39bc, 0x343a, 0x3b07, 0x2af1, 0x383a, 0x2cb3, 0x3a94, + 0x321d, 0x3bb6, 0x31ec, 0x3ba1, 0x3989, 0x336c, 0x3a85, 0x3a9d, 0x3be9, 0x3a81, 0x30b4, 0x3094, + 0x395a, 0x30c6, 0x3aa1, 0x398d, 0x3b2c, 0x3845, 0x3633, 0x2c3b, 0x3808, 0x2a27, 0x3816, 0x387b, + 0x39f4, 0x3507, 0x3b6c, 0x3ae5, 0x34ef, 0x3a3c, 0x3ad5, 0x39e5, 0x3a8c, 0x3850, 0x24dc, 0x3b5c, + 0x3453, 0x3449, 0x3078, 0x30d5, 0x375e, 0x3901, 0x325e, 0x38e7, 0x376c, 0x32df, 0x39c2, 0x37b3, + 0x33c5, 0x3669, 0x33f8, 0x34ad, 0x3b8c, 0x3742, 0x3831, 0x3a47, 0x2fc0, 0x3077, 0x26a3, 0x3410, + 0x3be2, 0x306c, 0x3a3b, 0x3bb4, 0x3760, 0x38b6, 0x2e5d, 0x3a60, 0x3415, 0x3b20, 0x3935, 0x35e3, + 0x33ae, 0x3b86, 0x1388, 0x3b7c, 0x3837, 0x2d4b, 0x3a1a, 0x346a, 0x311f, 0x3a92, 0x354e, 0x3786, + 0x3328, 0x3a07, 0x338a, 0x39af, 0x39b5, 0x3b19, 0x388f, 0x30f7, 0x3648, 0x380a, 0x3984, 0x395c, + 0x3702, 0x2ad3, 0x3b3e, 0x35ca, 0x2b7a, 0x39a8, 0x3966, 0x3acb, 0x3add, 0x3b54, 0x2285, 0x3bbf, + 0x3a67, 0x393f, 0x3b14, 0x3a76, 0x30fb, 0x2492, 0x37d0, 0x3915, 0x2dbc, 0x36a7, 0x33f3, 0x3032, + 0x2d42, 0x38e1, 0x336b, 0x3b4f, 0x2ebb, 0x35c8, 0x2c04, 0x3777, 0x2c2b, 0x3a08, 0x3615, 0x3424, + 0x2c7e, 0x3b53, 0x361d, 0x364c, 0x3b63, 0x3b1f, 0x3653, 0x2a0a, 0x38c1, 0x3a35, 0x38fa, 0x39b0, + 0x2ea5, 0x39f1, 0x340f, 0x3873, 0x3a39, 0x3826, 0x3853, 0x359b, 0x3b5f, 0x344a, 0x3a42, 0x30d3, + 0x382a, 0x37e4, 0x2a05, 0x373b, 0x315c, 0x2aae, 0x3471, 0x3948, 0x346d, 0x3b4f, 0x2d18, 0x3518, + 0x3554, 0x386a, 0x3272, 0x374b, 0x3321, 0x393c, 0x33f0, 0x38a5, 0x3957, 0x357e, 0x3a0c, 0x3ac7, + 0x3b1d, 0x395d, 0x398a, 0x3a6e, 0x3baf, 0x38b2, 0x37ec, 0x3233, 0x3bd6, 0x3481, 0x39de, 0x26e3, + 0x2f66, 0x3b84, 0x3a5a, 0x38f3, 0x387e, 0x322b, 0x2169, 0x3988, 0x3932, 0x22a9, 0x3162, 0x3b76, + 0x2632, 0x3af3, 0x3827, 0x30e6, 0x32f7, 0x29a2, 0x3a2a, 0x3885, 0x39b6, 0x3540, 0x3abd, 0x3832, + 0x34c8, 0x3a35, 0x3ae9, 0x31fd, 0x3839, 0x378c, 0x3862, 0x3095, 0x36ff, 0x36dc, 0x293b, 0x2c4e, + 0x3618, 0x357c, 0x343e, 0x3a8d, 0x39f0, 0x3294, 0x3859, 0x27e7, 0x3676, 0x39c7, 0x38ef, 0x37e3, + 0x3b34, 0x3b78, 0x3ae2, 0x35b7, 0x3b88, 0x3bd6, 0x3478, 0x3b95, 0x3894, 0x2fab, 0x3687, 0x3605, + 0x38ed, 0x38b8, 0x3b9d, 0x27f6, 0x3ba9, 0x3a89, 0x3308, 0x2658, 0x3864, 0x3770, 0x3a8a, 0x38fd, + 0x345e, 0x3541, 0x3b3a, 0x3833, 0x3a62, 0x3a26, 0x3a8a, 0x3b96, 0x37b9, 0x33fb, 0x322b, 0x3217, + 0x34dc, 0x39a4, 0x3bd8, 0x33b6, 0x3696, 0x368f, 0x3bb6, 0x39a4, 0x3b6e, 0x38ef, 0x3044, 0x2ec4, + 0x39fd, 0x3ae4, 0x366c, 0x33d7, 0x3b7e, 0x33c8, 0x3953, 0x376a, 0x3535, 0x3243, 0x388f, 0x3601, + 0x3bf7, 0x3397, 0x3bfa, 0x36dc, 0x32e3, 0x1edc, 0x3770, 0x391c, 0x384d, 0x3a33, 0x37a4, 0x3997, + 0x37f1, 0x3929, 0x35f3, 0x39a6, 0x2c0e, 0x3a0d, 0x2d8a, 0x3863, 0x2eb6, 0x34fe, 0x3a39, 0x3a75, + 0x2ba6, 0x3394, 0x3326, 0x3329, 0x32d3, 0x3bb7, 0x351d, 0x38de, 0x3889, 0x38ea, 0x2ea1, 0x36aa, + 0x2ec7, 0x3926, 0x3505, 0x37f5, 0x35b5, 0x3b94, 0x3679, 0x36b6, 0x3a14, 0x3add, 0x2f3b, 0x355f, + 0x2fcf, 0x3939, 0x2941, 0x3a9a, 0x39d0, 0x3b59, 0x3904, 0x3b16, 0x2a30, 0x399a, 0x3b1a, 0x2e62, + 0x392e, 0x35d4, 0x289a, 0x3456, 0x3315, 0x356d, 0x347a, 0x3882, 0x326e, 0x3a22, 0x2ee6, 0x26a0, + 0x2119, 0x3468, 0x3a9d, 0x35aa, 0x3840, 0x36a1, 0x3a76, 0x253b, 0x3b69, 0x3a7b, 0x2444, 0x22a4, + 0x322f, 0x38bc, 0x2e1f, 0x3821, 0x3ba6, 0x2c72, 0x3b09, 0x3a60, 0x34a8, 0x35f2, 0x35aa, 0x3441, + 0x35f5, 0x3945, 0x39c2, 0x3160, 0x39ce, 0x3a06, 0x32a0, 0x3582, 0x36c9, 0x3967, 0x31c8, 0x3819, + 0x3a6c, 0x3b57, 0x3206, 0x3a5a, 0x36d4, 0x39f6, 0x3617, 0x34dd, 0x3052, 0x3243, 0x33b5, 0x38ee, + 0x3ada, 0x328e, 0x3535, 0x2d8b, 0x3a0f, 0x2dab, 0x36b3, 0x300c, 0x2f0e, 0x2dd7, 0x3849, 0x3927, + 0x3a4b, 0x3a81, 0x31e2, 0x3497, 0x3211, 0x2fc8, 0x3658, 0x391b, 0x3a74, 0x32eb, 0x35ca, 0x382e, + 0x3b76, 0x30a9, 0x302a, 0x3be2, 0x3a3d, 0x39a4, 0x3b82, 0x3279, 0x35ec, 0x3bc3, 0x3ac5, 0x3484, + 0x3734, 0x32f9, 0x3aab, 0x38fd, 0x3b09, 0x2134, 0x3408, 0x2f12, 0x3668, 0x3abe, 0x34c1, 0x390f, + 0x2eca, 0x39a4, 0x3bf0, 0x3015, 0x2ea4, 0x2d2b, 0x2de4, 0x3090, 0x37ac, 0x2f8b, 0x3815, 0x364f, + 0x3a98, 0x3b25, 0x3256, 0x39bd, 0x3aa4, 0x38c5, 0x3621, 0x3271, 0x3ad0, 0x2d6c, 0x38ea, 0x3af6, + 0x38bd, 0x3b9b, 0x30b7, 0x34c7, 0x395d, 0x358b, 0x3b7e, 0x3a3b, 0x349f, 0x26bd, 0x3450, 0x31a3, + 0x3b5a, 0x2c24, 0x3abd, 0x398f, 0x3087, 0x345f, 0x3752, 0x3a6c, 0x3937, 0x3325, 0x392a, 0x3518, + 0x3adb, 0x38e0, 0x37c0, 0x26fa, 0x2bf1, 0x3782, 0x3b84, 0x397b, 0x2774, 0x32e5, 0x23c4, 0x33e4, + 0x378f, 0x2fe5, 0x2f21, 0x3001, 0x3bc9, 0x3a3c, 0x38bd, 0x38d0, 0x363b, 0x3a8a, 0x3687, 0x2e6a, + 0x3bef, 0x3b90, 0x3712, 0x30f7, 0x3be2, 0x2621, 0x39dd, 0x3932, 0x373f, 0x398f, 0x3937, 0x34c3, + 0x3a34, 0x2e3d, 0x3bb3, 0x361a, 0x36b9, 0x2c6a, 0x38de, 0x39a1, 0x395f, 0x280c, 0x371b, 0x33c3, + 0x2d37, 0x389e, 0x2ddc, 0x2bd2, 0x3471, 0x34e3, 0x36de, 0x305f, 0x3ab5, 0x3514, 0x327b, 0x309e, + 0x360c, 0x2d09, 0x3b2a, 0x3b49, 0x38b0, 0x37b3, 0x2f97, 0x3ad7, 0x38a2, 0x351c, 0x3bdf, 0x3877, + 0x3ad6, 0x3b26, 0x3ba5, 0x3318, 0x3bd7, 0x3907, 0x3983, 0x33b6, 0x34b7, 0x3bf5, 0x38e7, 0x3b82, + 0x2d0e, 0x3a8b, 0x382b, 0x3594, 0x2f6f, 0x3667, 0x3a56, 0x2f88, 0x3b3f, 0x3b82, 0x2dbf, 0x379b, + 0x386a, 0x39e3, 0x3320, 0x39aa, 0x3821, 0x38db, 0x337b, 0x384b, 0x3a06, 0x3a5f, 0x182f, 0x35e2, + 0x3b22, 0x1e2a, 0x3b64, 0x35b2, 0x3884, 0x360c, 0x36b1, 0x3928, 0x36fa, 0x358c, 0x396f, 0x366f, + 0x3986, 0x3a4f, 0x381c, 0x301a, 0x38fe, 0x36e1, 0x34d1, 0x3b30, 0x36ac, 0x3803, 0x3888, 0x38d9, + 0x3853, 0x35d6, 0x3469, 0x39da, 0x3829, 0x355c, 0x3803, 0x3834, 0x3a1d, 0x35e3, 0x397d, 0x2f1a, + 0x3b10, 0x3486, 0x3b0b, 0x3b2f, 0x38b6, 0x3690, 0x3b7b, 0x39b1, 0x385b, 0x3bad, 0x3102, 0x32ef, + 0x39e2, 0x37dd, 0x2d05, 0x3a1b, 0x3bd5, 0x30d5, 0x3131, 0x2c1d, 0x3a47, 0x386e, 0x3481, 0x2530, + 0x351b, 0x34e2, 0x336d, 0x35c2, 0x331d, 0x38cf, 0x2d9a, 0x394b, 0x296b, 0x3401, 0x386d, 0x34d5, + 0x37a2, 0x3bd2, 0x39c2, 0x2756, 0x2553, 0x3289, 0x38f0, 0x3af7, 0x3791, 0x3b28, 0x37e3, 0x39b7, + 0x3ba9, 0x3404, 0x3755, 0x3a3b, 0x2f50, 0x38c1, 0x3761, 0x2ded, 0x3ba6, 0x318f, 0x3a6f, 0x39fd, + 0x3b99, 0x31bd, 0x3821, 0x3bd8, 0x3b96, 0x3a18, 0x383c, 0x1baa, 0x3acb, 0x391d, 0x3149, 0x307f, + 0x3836, 0x2d47, 0x3b56, 0x346f, 0x3a5e, 0x2bb4, 0x3819, 0x2f90, 0x3a5d, 0x38fe, 0x2fff, 0x39bb, + 0x3b8d, 0x3901, 0x37cf, 0x38dc, 0x3690, 0x3b45, 0x3101, 0x3bbf, 0x3b00, 0x28a7, 0x3a4d, 0x3a90, + 0x3b87, 0x3b1f, 0x35c6, 0x37af, 0x3796, 0x3beb, 0x3a72, 0x3887, 0x284e, 0x3b05, 0x32e5, 0x3837, + 0x39b3, 0x36e8, 0x3b7d, 0x3726, 0x2899, 0x3b90, 0x33d7, 0x357f, 0x388e, 0x2ec2, 0x3b1e, 0x393b, + 0x3ac7, 0x3844, 0x3612, 0x3a08, 0x319d, 0x38da, 0x3a50, 0x3abd, 0x3451, 0x3b78, 0x2dcf, 0x21b8, + 0x3505, 0x3492, 0x3aa2, 0x304d, 0x3999, 0x3af3, 0x3966, 0x35d5, 0x3325, 0x3a6b, 0x34b8, 0x3123, + 0x37d6, 0x3bb6, 0x3818, 0x39df, 0x3463, 0x34b6, 0x3739, 0x38a3, 0x38ea, 0x39fb, 0x3774, 0x38e1, + 0x39dd, 0x3194, 0x3a69, 0x38cf, 0x3a3f, 0x3870, 0x3b80, 0x2e42, 0x3792, 0x3778, 0x34df, 0x3453, + 0x3840, 0x3bf1, 0x37d9, 0x3798, 0x2ca7, 0x3a7e, 0x3240, 0x3250, 0x3a08, 0x2f88, 0x3bcf, 0x3ad6, + 0x3919, 0x1a97, 0x37d2, 0x331a, 0x34d9, 0x38b5, 0x367d, 0x305f, 0x38f8, 0x347e, 0x31ed, 0x3b4c, + 0x3950, 0x3976, 0x3297, 0x3bc8, 0x3950, 0x3759, 0x28b8, 0x3323, 0x38c4, 0x33cd, 0x2ef0, 0x2eba, + 0x32dd, 0x3a41, 0x307d, 0x2a3c, 0x3b22, 0x33fa, 0x32f7, 0x3b54, 0x30e8, 0x3a5e, 0x3b0d, 0x349f, + 0x3a5b, 0x3bc0, 0x38a0, 0x3247, 0x3444, 0x357e, 0x3611, 0x26f3, 0x3b63, 0x3a31, 0x3a65, 0x385b, + 0x3b77, 0x34fc, 0x380c, 0x38fb, 0x36dd, 0x39e6, 0x3719, 0x2e8c, 0x3407, 0x3161, 0x39ac, 0x3842, + 0x37cc, 0x3a17, 0x3452, 0x35c1, 0x3a5b, 0x39bd, 0x38a0, 0x39c2, 0x30ac, 0x345e, 0x3710, 0x3b30, + 0x3038, 0x2b7a, 0x2494, 0x1db7, 0x3b83, 0x32a0, 0x3b2f, 0x3ac1, 0x3512, 0x3662, 0x3656, 0x3470, + 0x3524, 0x3bbb, 0x3650, 0x3878, 0x3928, 0x36c2, 0x34aa, 0x3ae7, 0x36c1, 0x3a35, 0x36f7, 0x2fe3, + 0x2d17, 0x302d, 0x310f, 0x3260, 0x3826, 0x3162, 0x36f0, 0x3bf7, 0x3918, 0x2bdb, 0x35fd, 0x3984, + 0x314d, 0x2400, 0x3867, 0x3926, 0x2cf4, 0x3958, 0x38e1, 0x3876, 0x393d, 0x369f, 0x3709, 0x39b7, + 0x2960, 0x3aaf, 0x35fc, 0x3bf7, 0x390b, 0x34f5, 0x3856, 0x3171, 0x3895, 0x1e18, 0x323e, 0x389c, + 0x3970, 0x28af, 0x3bd3, 0x3489, 0x3955, 0x3544, 0x36c8, 0x34d7, 0x38cf, 0x2c56, 0x3409, 0x320d, + 0x1f86, 0x3a18, 0x3385, 0x3082, 0x3574, 0x2cd1, 0x392c, 0x3681, 0x39f6, 0x397c, 0x29bb, 0x3615, + 0x2e16, 0x3b61, 0x390d, 0x318e, 0x31f0, 0x3836, 0x3ad6, 0x27dd, 0x3924, 0x2e6b, 0x37f0, 0x3460, + 0x396a, 0x35e9, 0x2241, 0x34d7, 0x3a17, 0x3482, 0x28f3, 0x2802, 0x3a32, 0x3aea, 0x38ad, 0x3932, + 0x3acb, 0x36ca, 0x3bdf, 0x292d, 0x3abe, 0x39f0, 0x38a5, 0x33e8, 0x2dbb, 0x3b56, 0x381c, 0x3ae0, + 0x38c6, 0x268f, 0x3791, 0x338e, 0x3585, 0x2e4b, 0x3b3b, 0x34d4, 0x3959, 0x3acc, 0x3532, 0x375c, + 0x378e, 0x369f, 0x3755, 0x34cd, 0x38a4, 0x301d, 0x31be, 0x3baf, 0x2f01, 0x385e, 0x36cb, 0x3705, + 0x3554, 0x3813, 0x3936, 0x384a, 0x397e, 0x3851, 0x3711, 0x3992, 0x38f1, 0x399b, 0x3650, 0x3951, + 0x2f57, 0x3a85, 0x3be3, 0x3899, 0x38bd, 0x3952, 0x3826, 0x3897, 0x3ac0, 0x39ae, 0x3b07, 0x3297, + 0x331e, 0x38d3, 0x396a, 0x3a4a, 0x3646, 0x3ae4, 0x3824, 0x3598, 0x33d8, 0x3945, 0x371a, 0x3509, + 0x3b58, 0x3806, 0x39a1, 0x3aee, 0x389b, 0x39e3, 0x3b5a, 0x3754, 0x3ab7, 0x37ee, 0x2e4f, 0x38f7, + 0x38f0, 0x3241, 0x3a33, 0x395a, 0x3659, 0x2d3c, 0x2d66, 0x3850, 0x3b82, 0x39f2, 0x3bca, 0x37a0, + 0x3adc, 0x3975, 0x3168, 0x39eb, 0x3b70, 0x2ece, 0x31ff, 0x3623, 0x1cca, 0x380a, 0x3bc0, 0x370c, + 0x38dc, 0x3b80, 0x375d, 0x372c, 0x3b52, 0x3b67, 0x37d7, 0x2c50, 0x39f6, 0x39a0, 0x392b, 0x343d, + 0x3b2c, 0x3816, 0x2bd5, 0x389b, 0x37a1, 0x32c6, 0x37bc, 0x3b7c, 0x358c, 0x30b0, 0x3bd7, 0x3a6e, + 0x37de, 0x3330, 0x2e8a, 0x353c, 0x3b3d, 0x3956, 0x3bcf, 0x301e, 0x36ad, 0x3a37, 0x3b42, 0x383e, + 0x36d1, 0x3a53, 0x3bba, 0x2ac8, 0x394c, 0x3b04, 0x3460, 0x3642, 0x38d4, 0x26da, 0x3989, 0x3aad, + 0x380d, 0x3a1b, 0x3638, 0x355e, 0x3b4b, 0x310e, 0x35b0, 0x2efd, 0x39bc, 0x3ba9, 0x3a07, 0x34c8, + 0x2c21, 0x3aa7, 0x37aa, 0x35c8, 0x2db5, 0x352c, 0x38a7, 0x37ef, 0x3323, 0x3a2f, 0x32da, 0x33a6, + 0x3226, 0x3053, 0x39cc, 0x349c, 0x2821, 0x3b7b, 0x2c88, 0x354f, 0x3a0b, 0x3b10, 0x3a6e, 0x3949, + 0x360c, 0x3bb1, 0x3bc1, 0x3888, 0x3402, 0x3102, 0x3511, 0x3b3c, 0x38ba, 0x335a, 0x27b9, 0x3215, + 0x389c, 0x37a2, 0x346f, 0x39cf, 0x3a60, 0x37f1, 0x3426, 0x3bd7, 0x3be2, 0x3910, 0x3b40, 0x3a0e, + 0x3aad, 0x32da, 0x37af, 0x3bb5, 0x36ad, 0x3262, 0x2aae, 0x3085, 0x3a1e, 0x388c, 0x38ab, 0x3742, + 0x2393, 0x3b6b, 0x3a53, 0x3b0d, 0x2d23, 0x3354, 0x38eb, 0x3a07, 0x377a, 0x3bb6, 0x3328, 0x3873, + 0x3a9e, 0x36df, 0x32ad, 0x3345, 0x31d5, 0x359f, 0x221b, 0x3a16, 0x35d0, 0x361a, 0x3aac, 0x3b79, + 0x38b5, 0x3a28, 0x3700, 0x3b8e, 0x3aca, 0x35e8, 0x396e, 0x39b7, 0x36ad, 0x2aa7, 0x3b8b, 0x372d, + 0x2ae7, 0x3a7f, 0x3b58, 0x3861, 0x3b16, 0x329a, 0x3b6a, 0x334e, 0x3aa7, 0x30a9, 0x3385, 0x3bb4, + 0x32fa, 0x2a3a, 0x3540, 0x2ef0, 0x303b, 0x387c, 0x38fc, 0x380f, 0x39fe, 0x2e69, 0x3849, 0x32a0, + 0x38f2, 0x3851, 0x37e4, 0x2540, 0x3975, 0x2eff, 0x361f, 0x3392, 0x347c, 0x36fd, 0x3bcd, 0x3af0, + 0x3944, 0x3867, 0x2ce0, 0x3757, 0x1ca3, 0x3acf, 0x3baf, 0x3bf8, 0x365b, 0x3920, 0x2aa7, 0x3b21, + 0x3408, 0x3720, 0x3ae0, 0x3845, 0x3a03, 0x24b4, 0x390f, 0x1cdd, 0x34f8, 0x3437, 0x3b5b, 0x39d4, + 0x3885, 0x3418, 0x3ace, 0x387c, 0x32b3, 0x30dc, 0x392a, 0x330a, 0x2aa0, 0x3432, 0x3b83, 0x32f1, + 0x2d12, 0x3639, 0x3909, 0x3a99, 0x384a, 0x3509, 0x3472, 0x3896, 0x2c46, 0x37ee, 0x3a2c, 0x2cf3, + 0x3bc9, 0x3b86, 0x3b7a, 0x364d, 0x38bb, 0x34d8, 0x3787, 0x3789, 0x3a42, 0x2703, 0x3849, 0x328f, + 0x38ce, 0x2b0b, 0x3bdb, 0x2e3d, 0x34e2, 0x3bfa, 0x371c, 0x3a3c, 0x350c, 0x39b8, 0x3903, 0x3a6c, + 0x3666, 0x2c34, 0x3566, 0x3b12, 0x31ef, 0x39ea, 0x2b79, 0x3924, 0x299f, 0x2c72, 0x302f, 0x2d50, + 0x36f2, 0x3bbc, 0x3b41, 0x39be, 0x3b2f, 0x3061, 0x37a2, 0x3571, 0x3ae0, 0x32a5, 0x3740, 0x3a56, + 0x3734, 0x2eee, 0x39b7, 0x36d9, 0x3494, 0x34c1, 0x3141, 0x2e0f, 0x36db, 0x3884, 0x2e5e, 0x3a3f, + 0x31e4, 0x3118, 0x3789, 0x3722, 0x3a1f, 0x3989, 0x3afc, 0x32ca, 0x391a, 0x38ae, 0x2eaf, 0x38c0, + 0x37b2, 0x3842, 0x3978, 0x39b0, 0x3b70, 0x3455, 0x3b54, 0x3ae3, 0x3b2b, 0x34af, 0x2db7, 0x3b6f, + 0x3a31, 0x3a1e, 0x3ab3, 0x355b, 0x3a4d, 0x333e, 0x3069, 0x3b8a, 0x39b1, 0x3509, 0x387f, 0x3b22, + 0x3a91, 0x38c3, 0x3b78, 0x3459, 0x38a9, 0x32ff, 0x3230, 0x3af4, 0x39da, 0x30c9, 0x3b51, 0x380d, + 0x3726, 0x360e, 0x2816, 0x3308, 0x3a3c, 0x37f9, 0x37ee, 0x30ea, 0x3903, 0x3514, 0x398e, 0x35de, + 0x39cf, 0x3a63, 0x3af0, 0x2732, 0x380a, 0x3548, 0x26b0, 0x38d7, 0x38e2, 0x3935, 0x3a8d, 0x315a, + 0x3b20, 0x389a, 0x3ade, 0x3bc4, 0x3654, 0x36c7, 0x271b, 0x38bb, 0x315c, 0x3728, 0x340f, 0x380d, + 0x2cbc, 0x3adb, 0x299c, 0x365f, 0x39f6, 0x338d, 0x31d9, 0x3aa7, 0x3494, 0x349d, 0x3ae8, 0x3020, + 0x3abb, 0x3949, 0x3747, 0x366b, 0x2d3f, 0x35c9, 0x3b18, 0x3a34, 0x38e6, 0x284a, 0x37bd, 0x32f3, + 0x35d7, 0x3782, 0x3ab9, 0x3832, 0x3002, 0x3bdb, 0x30e9, 0x39a5, 0x3a89, 0x3a6f, 0x3a07, 0x3bb9, + 0x3687, 0x3865, 0x35d8, 0x3a83, 0x37d6, 0x3827, 0x3a45, 0x3962, 0x35df, 0x2ea9, 0x3955, 0x3582, + 0x37ad, 0x3382, 0x3507, 0x3966, 0x2c40, 0x37ef, 0x31ad, 0x39ff, 0x2863, 0x3a05, 0x2932, 0x2e97, + 0x3153, 0x3b3e, 0x3237, 0x3b24, 0x3262, 0x3ba3, 0x3b37, 0x3a33, 0x2499, 0x3661, 0x2a11, 0x3618, + 0x2a3f, 0x39e2, 0x1c4a, 0x3a51, 0x2d39, 0x3268, 0x2f51, 0x341e, 0x39f9, 0x3833, 0x32a3, 0x3952, + 0x37ce, 0x39d2, 0x2d87, 0x320f, 0x34e6, 0x3840, 0x3684, 0x318b, 0x3460, 0x39ca, 0x386f, 0x2979, + 0x3ba1, 0x3a8c, 0x3341, 0x3845, 0x3acd, 0x2b68, 0x2827, 0x3547, 0x2e0a, 0x39db, 0x381b, 0x3969, + 0x3501, 0x38d4, 0x3ba7, 0x35f7, 0x351b, 0x3285, 0x3861, 0x3957, 0x36e2, 0x32c4, 0x3581, 0x3bb7, + 0x3b2f, 0x3a00, 0x3609, 0x3ab8, 0x3b09, 0x34c6, 0x391e, 0x3257, 0x3b08, 0x3bc0, 0x364f, 0x3910, + 0x3a1f, 0x37c2, 0x3522, 0x34c6, 0x3bb9, 0x38ba, 0x2f63, 0x38c3, 0x38a6, 0x3436, 0x3af1, 0x346f, + 0x3774, 0x3b0c, 0x3409, 0x3b6c, 0x3394, 0x3a2f, 0x3abc, 0x2ea9, 0x3501, 0x3a31, 0x2edc, 0x341e, + 0x3be5, 0x3a01, 0x3372, 0x3814, 0x3b88, 0x3811, 0x3956, 0x3bc0, 0x338b, 0x3075, 0x3957, 0x3ba1, + 0x2f43, 0x386d, 0x388f, 0x376c, 0x3a09, 0x38b2, 0x3a12, 0x3a4d, 0x2eb5, 0x3afc, 0x3477, 0x349d, + 0x3403, 0x35e8, 0x3a01, 0x37c2, 0x3a3c, 0x3ab6, 0x3165, 0x3bd0, 0x3832, 0x36c7, 0x38be, 0x38fb, + 0x3916, 0x3574, 0x31b1, 0x3b73, 0x3635, 0x38f4, 0x32ac, 0x25c6, 0x38f2, 0x248f, 0x3ae9, 0x384f, + 0x374a, 0x3bf2, 0x3bf5, 0x3719, 0x3b78, 0x3688, 0x2ed4, 0x3443, 0x305c, 0x390d, 0x38d0, 0x34dd, + 0x3662, 0x3902, 0x3752, 0x3b76, 0x347b, 0x356c, 0x3809, 0x3b59, 0x3a41, 0xbb1, 0x3872, 0x362e, + 0x3669, 0x3741, 0x3a79, 0x3560, 0x1ca8, 0x38da, 0x3901, 0x34a3, 0x3b63, 0x391c, 0x3990, 0x39af, + 0x3bd2, 0x3afb, 0x3b68, 0x354e, 0x39ba, 0x35ca, 0x3483, 0x3aaf, 0x3489, 0x2fbe, 0x38e7, 0x3678, + 0x3928, 0x2358, 0x372e, 0x37d9, 0x3929, 0x3695, 0x3607, 0x2c73, 0x37d7, 0x39ee, 0x3acd, 0x3898, + 0x3580, 0x3bd5, 0x3a67, 0x2f13, 0x388d, 0x3a39, 0x2d6e, 0x389d, 0x359d, 0x37a3, 0x37f4, 0x31bf, + 0x36cb, 0x3bc2, 0x3b4d, 0x3077, 0x35d8, 0x3afb, 0x36bf, 0x31c7, 0x36b7, 0x3ac9, 0x2076, 0x2f55, + 0x392e, 0x348d, 0x305e, 0x3a4b, 0x36e3, 0x3acf, 0x34e2, 0x396a, 0x3785, 0x3bf8, 0x354d, 0x36bd, + 0x395c, 0x3313, 0x39ad, 0x2ede, 0x3561, 0x3a82, 0x30bb, 0x34fc, 0x2fae, 0x3b98, 0x36c8, 0x3ad8, + 0x3813, 0x39f3, 0x3bc3, 0x3b85, 0x3aa0, 0x3a09, 0x368a, 0x2ddb, 0x39d7, 0x32f6, 0x3b8c, 0x3b51, + 0x39bd, 0x3680, 0x3b92, 0x3825, 0x3798, 0x3a62, 0x3847, 0x3a30, 0x393e, 0x38de, 0x38e9, 0x3a64, + 0x3a29, 0x3a25, 0x386e, 0x315f, 0x2de2, 0x3be7, 0x3bc1, 0x35ef, 0x35bb, 0x3968, 0x3a64, 0x34ff, + 0x3766, 0x3b8e, 0x3657, 0x344a, 0x2cd0, 0x377c, 0x3881, 0x3456, 0x350b, 0x3a5f, 0x3b5f, 0x3960, + 0x3767, 0x38b4, 0x3729, 0x3b19, 0x35c4, 0x3bc1, 0x32d9, 0x3185, 0x3b32, 0x3108, 0x3775, 0x3b82, + 0x3803, 0x38e2, 0x3aa4, 0x3b1e, 0x30a1, 0x3bc1, 0x3b4d, 0x36ad, 0x2192, 0x2837, 0x3b53, 0x3ab8, + 0x3883, 0x3b36, 0x3418, 0x3ac1, 0x3589, 0x38ae, 0x3614, 0x3172, 0x2e48, 0x3b6a, 0x39f1, 0x3828, + 0x3550, 0x2cf0, 0x39ac, 0x2bcb, 0x38e9, 0x3498, 0x3a3a, 0x307f, 0x3887, 0x2675, 0x3705, 0x371e, + 0x3982, 0x3ba9, 0x38d0, 0x39f8, 0x3413, 0x3483, 0x32b8, 0x3720, 0x357d, 0x39b4, 0x39bf, 0x38c8, + 0x3550, 0x3071, 0x39f2, 0x29ae, 0x2348, 0x3ae3, 0x3792, 0x3b98, 0x3b40, 0x390a, 0x38e3, 0x3a78, + 0x3875, 0x3a63, 0x39e2, 0x3b24, 0x3288, 0x35c4, 0x35b4, 0x3a60, 0x31d2, 0x39ca, 0x2527, 0x3445, + 0x3b44, 0x315b, 0x2553, 0x3453, 0x2ddd, 0x3889, 0x2897, 0x37da, 0x3553, 0x3826, 0x39a0, 0x38b1, + 0x2681, 0x38f4, 0x351c, 0x3bdf, 0x3ac9, 0x3a44, 0x37fd, 0x394c, 0x2f46, 0x28ca, 0x3097, 0x30f2, + 0x3830, 0x3711, 0x36ba, 0x3ba8, 0x3570, 0x38b5, 0x3943, 0x398d, 0x3994, 0x3109, 0x30dc, 0x3a40, + 0x3648, 0x2050, 0x329e, 0x3432, 0x35b8, 0x3667, 0x3b4a, 0x29fe, 0x35cc, 0x3675, 0x3b8e, 0x34cb, + 0x3531, 0x2acc, 0x395d, 0x3411, 0x3a65, 0x3a30, 0x35f6, 0x3710, 0x364f, 0x2f34, 0x38d8, 0x39d5, + 0x2e37, 0x350d, 0x39fe, 0x37ed, 0x3726, 0x3a6b, 0x3b6f, 0x35ce, 0x38bc, 0x3929, 0x33d7, 0x28ef, + 0x38d7, 0x35df, 0x3ac8, 0x333d, 0x2356, 0x35d5, 0x377b, 0x3bca, 0x3ad7, 0x309f, 0x36d3, 0x2bf6, + 0x373f, 0x2c5f, 0x374a, 0x35f0, 0x397a, 0x34fc, 0x2dd8, 0x3947, 0x3bcc, 0x3bfb, 0x3366, 0x3721, + 0x310a, 0x3433, 0x391e, 0x375e, 0x367c, 0x3a07, 0x3873, 0x34d6, 0x2f47, 0x3771, 0x3a83, 0x3bee, + 0x36d7, 0x3b2f, 0x39be, 0x305e, 0x21cc, 0x2e70, 0x388c, 0x34f2, 0x393b, 0x3610, 0x3a59, 0x3294, + 0x2fa8, 0x3343, 0x3740, 0x38e3, 0x3a0c, 0x302d, 0x3ba9, 0x34f1, 0x3879, 0x29cc, 0x35e0, 0x31d0, + 0x381b, 0x3bcd, 0x35a5, 0x3a87, 0x369d, 0x35b9, 0x2eba, 0x3992, 0x3ae3, 0x393c, 0x3a39, 0x31b2, + 0x3b4d, 0x3868, 0x364a, 0x3164, 0x348c, 0x30c8, 0x3bd3, 0x3a96, 0x3570, 0x31ce, 0x357f, 0x1fb0, + 0x3a40, 0x38bd, 0x2802, 0x376e, 0x35c3, 0x3264, 0x33ac, 0x3878, 0x3a0c, 0x3a25, 0x38cb, 0x247a, + 0x384b, 0x3a58, 0x357c, 0x36af, 0x384a, 0x3b93, 0x3a46, 0x348b, 0x3526, 0x3be8, 0x316c, 0x385c, + 0x3a41, 0x3b4d, 0x3045, 0x3a20, 0x3870, 0x3523, 0x38c0, 0x3636, 0x390a, 0x38f2, 0x2b41, 0x261a, + 0x380e, 0x3a74, 0x331a, 0x30ae, 0x37dd, 0x328c, 0x3a1c, 0x2fc0, 0x3994, 0x3095, 0x3900, 0x2cc8, + 0x38ec, 0x3bdc, 0x3820, 0x2b39, 0x3422, 0x38be, 0x3a1f, 0x3b2b, 0x38e6, 0x3839, 0x3afc, 0x3bb4, + 0x3422, 0x3b0f, 0x38f1, 0x3b5d, 0x39be, 0x341a, 0x374f, 0x31fe, 0x38bc, 0x38ff, 0x32d3, 0x38a0, + 0x3894, 0x396b, 0x395e, 0x3b0e, 0x39c2, 0x2f3e, 0x2d76, 0x38c5, 0x3365, 0x3685, 0x2d08, 0x3a5b, + 0x3693, 0x2e6e, 0x3b1a, 0x39bf, 0x347b, 0x2e04, 0x3b7a, 0x3b02, 0x3b57, 0x36ac, 0x32d3, 0x2273, + 0x33a6, 0x3542, 0x38d4, 0x3a1c, 0x3811, 0x33d8, 0x3b79, 0x390c, 0x2c29, 0x3858, 0x395d, 0x38d9, + 0x343a, 0x3148, 0x3715, 0x3966, 0x2fc6, 0x318e, 0x3784, 0x383e, 0x354d, 0x35a8, 0x38c7, 0x3662, + 0x32d3, 0x37be, 0x396a, 0x39a3, 0x39fd, 0x3b0f, 0x3bf3, 0x3a7b, 0x38d5, 0x3343, 0x3ae6, 0x3926, + 0x3a7a, 0x3744, 0x3acb, 0x39b8, 0x3ab1, 0x3bad, 0x392a, 0x390c, 0x2f37, 0x2ab5, 0x2935, 0x384a, + 0x3235, 0x38d2, 0x360d, 0x38de, 0x3948, 0x383f, 0x241a, 0x3bb0, 0x36cb, 0x3590, 0x369c, 0x3680, + 0x39d3, 0x3a6e, 0x39db, 0x390e, 0x398f, 0x3baf, 0x38d0, 0x3911, 0x3b72, 0x3407, 0x39e4, 0x3500, + 0x3844, 0x3283, 0x2f1a, 0x3bf1, 0x30bc, 0x3b2d, 0x3a43, 0x393f, 0x3405, 0x2671, 0x3b95, 0x361e, + 0x34ea, 0x3791, 0x39b2, 0x3136, 0x36af, 0x3435, 0x3b36, 0x3602, 0x356a, 0x388c, 0x3099, 0x33a3, + 0x37f2, 0x25e7, 0x393c, 0x398c, 0x2bc2, 0x36e0, 0x39d4, 0x3842, 0x3103, 0x39d1, 0x3653, 0x2c8a, + 0x38ed, 0x2920, 0x39c0, 0x3b94, 0x2da9, 0x3018, 0x2c9d, 0x3660, 0x2f3b, 0x2615, 0x3af0, 0x26ab, + 0x36ab, 0x2bdf, 0x38a0, 0x38f7, 0x33f2, 0x3bb2, 0x3a92, 0x3844, 0x2ab7, 0x3bee, 0x353d, 0x39ea, + 0x3abb, 0x3afe, 0x3052, 0x2d56, 0x38f7, 0x3a1a, 0x390a, 0x38b9, 0x384d, 0x31c6, 0x2ab4, 0x2a49, + 0x391a, 0x3871, 0x3474, 0x380f, 0x396b, 0x3b4b, 0x3486, 0x28c1, 0x2ecc, 0x3781, 0x35ad, 0x3208, + 0x3a2c, 0x3b69, 0x3b86, 0x388d, 0x3818, 0x38cd, 0x38d8, 0x28bb, 0x3bfd, 0x3b6e, 0x36a7, 0x31ab, + 0x342b, 0x315c, 0x3146, 0x1f51, 0x2708, 0x3b94, 0x3a14, 0x2f0e, 0x39d5, 0x398e, 0x3b9a, 0x356c, + 0x3009, 0x3111, 0x35e9, 0x39f9, 0x3b1b, 0x3b9f, 0x3b8c, 0x3a89, 0x3839, 0x37e7, 0x3527, 0x32d6, + 0x3826, 0x3132, 0x358e, 0x37b0, 0x3055, 0x3909, 0x33f4, 0x2bd3, 0x39ff, 0x2f9e, 0x348f, 0x382d, + 0x3a10, 0x34b0, 0x3833, 0x3873, 0x3840, 0x30a9, 0x3bb0, 0x2f6b, 0x3a1c, 0x35eb, 0x3a6a, 0x38ec, + 0x3050, 0x3981, 0x3645, 0x39fe, 0x2f66, 0x3aa0, 0x3a6b, 0x3b2f, 0x3941, 0x3521, 0x3095, 0x3b6f, + 0x38c6, 0x37dd, 0x3146, 0x39ea, 0x395c, 0x3a59, 0x3ae1, 0x3798, 0x289f, 0x36fa, 0x3b0a, 0x3adc, + 0x3392, 0x35f5, 0x3bbf, 0x3b31, 0x3087, 0x3a54, 0x3758, 0x3834, 0x3bcc, 0x3946, 0x3627, 0x3bae, + 0x39ac, 0x369f, 0x3841, 0x34b0, 0x3679, 0x3580, 0x32a7, 0x387d, 0x3aa8, 0x382a, 0x35f1, 0x3b90, + 0x36a2, 0x2d87, 0x30f4, 0x3b22, 0x359c, 0x3b7f, 0x344e, 0x3a94, 0x382d, 0x3a83, 0x39ae, 0x379e, + 0x2f7b, 0x39b3, 0x325e, 0x3873, 0x35ac, 0x378b, 0x3804, 0x3a5c, 0x33f3, 0x2e4e, 0x3b32, 0x3629, + 0x3bd6, 0x354b, 0x2952, 0x3828, 0x26d0, 0x39e2, 0x3bf7, 0x2d3c, 0x2754, 0x38f9, 0x3801, 0x39a0, + 0x34bb, 0x378f, 0x2e1a, 0x3999, 0x3ad5, 0x25f0, 0x3a4f, 0x275f, 0x3550, 0x318f, 0x3862, 0x3a96, + 0x38d5, 0x3927, 0x3010, 0x3a78, 0x2c99, 0x2bdd, 0x3b86, 0x34c2, 0x39a9, 0x35c5, 0x2e15, 0x383b, + 0x2f68, 0x399d, 0x290b, 0x375b, 0x39e8, 0x37ec, 0x3a06, 0x3780, 0x38ad, 0x356c, 0x32c9, 0x3b65, + 0x3819, 0x39e3, 0x3470, 0x2d14, 0x3ae8, 0x3952, 0x2e47, 0x37cc, 0x308c, 0x347a, 0x2d07, 0x3476, + 0x39b1, 0x3b7b, 0x2f49, 0x3aa6, 0x3994, 0x270e, 0x39d7, 0x286a, 0x2daa, 0x37ae, 0x38da, 0x3a14, + 0x3b0b, 0x3791, 0x35fe, 0x35a0, 0x38fb, 0x3b73, 0x24a6, 0x3b0d, 0x3891, 0x3441, 0x2542, 0x23ce, + 0x3af6, 0x38c5, 0x3bac, 0x3be4, 0x39f5, 0x3740, 0x3133, 0x2e12, 0x3b52, 0x3571, 0x3ae5, 0x353c, + 0x3a19, 0x343b, 0x3b41, 0x2f69, 0x36f0, 0x3ab5, 0x2a7a, 0x3568, 0x3ae6, 0x395b, 0x3bff, 0x332f, + 0x2848, 0x3417, 0x38a2, 0x3986, 0x3b1a, 0x3a47, 0x3aeb, 0x39b0, 0x363f, 0x3ba3, 0x385a, 0x3af3, + 0x373e, 0x3510, 0x2381, 0x37a8, 0x340d, 0x36b3, 0x3b10, 0x38ff, 0x32dd, 0x29a7, 0x3472, 0x3bc1, + 0x39de, 0x32bb, 0x3682, 0x3a8f, 0x378d, 0x39ff, 0x3a9d, 0x332a, 0x3801, 0x3a5d, 0x2e8b, 0x3841, + 0x3548, 0x3a75, 0x25a3, 0x3ab6, 0x37db, 0x37bf, 0x2c01, 0x3bf8, 0x3b7d, 0x1dfb, 0x26da, 0x3b6d, + 0x3895, 0x384c, 0x3877, 0x3a0f, 0x3ac2, 0x3bac, 0x3b42, 0x39b0, 0x338b, 0x3017, 0x3b42, 0x31f6, + 0x3bce, 0x3246, 0x2c63, 0x3bfd, 0x3924, 0x3a86, 0x3279, 0x3a88, 0x352d, 0x3bb0, 0x275d, 0x35b1, + 0x37dc, 0x325d, 0x36ff, 0x37b6, 0x3873, 0x353d, 0x2f62, 0x37cd, 0x3be9, 0x37c2, 0x38e7, 0x22df, + 0x3954, 0x3976, 0x3a05, 0x2e1f, 0x2def, 0x3bfc, 0x3aec, 0x385d, 0x3a08, 0x32e2, 0x3656, 0x38c4, + 0x3aa9, 0x31f3, 0x3afa, 0x35b6, 0x3910, 0x381b, 0x30e5, 0x3050, 0x396b, 0x38f4, 0x3b00, 0x3b63, + 0x3a2c, 0x39ec, 0x287e, 0x3873, 0x3890, 0x38b8, 0x3a4c, 0x3836, 0x31f0, 0x3732, 0x356b, 0x35de, + 0x3a8e, 0x36a4, 0x34a1, 0x377a, 0x3005, 0x3749, 0x39d8, 0x3bee, 0x38e9, 0x34d2, 0x32d6, 0x3883, + 0x3a5c, 0x2e19, 0x3aa8, 0x3881, 0x3306, 0x3790, 0x39ff, 0x35fb, 0x3b01, 0x2f92, 0x3302, 0x37c7, + 0x3635, 0x3a56, 0x3106, 0x3997, 0x3af7, 0x36e7, 0x39b8, 0x3aa0, 0x3b1a, 0x326a, 0x1dca, 0x3af8, + 0x383f, 0x3ba6, 0x21e0, 0x3540, 0x3ba7, 0x358d, 0x2ee4, 0x36e3, 0x3b47, 0x38a3, 0x3a38, 0x2bc4, + 0x3ae2, 0x3a5c, 0x381c, 0x3912, 0x39ad, 0x3078, 0x35dc, 0x30f2, 0x374c, 0x351f, 0x30af, 0x3aaf, + 0x1d79, 0x36b1, 0x2edc, 0x21fd, 0x3445, 0x374b, 0x388e, 0x39fb, 0x325e, 0x39a5, 0x3a63, 0x338d, + 0x3abf, 0x1067, 0x38a2, 0x2389, 0x3a47, 0x3908, 0x33aa, 0x39ac, 0x3bc2, 0x370c, 0x3621, 0x3818, + 0x2edf, 0x39c2, 0x3735, 0x3745, 0x3806, 0x389a, 0x3b05, 0x2755, 0x344a, 0x332a, 0x3a6b, 0x3854, + 0x31b5, 0x374a, 0x354f, 0x3aa4, 0x36a1, 0x374a, 0x3b57, 0x2c4b, 0x36b2, 0x3066, 0x35de, 0x3820, + 0x3ae5, 0x3a97, 0x3780, 0x24cc, 0x3831, 0x29b7, 0x3880, 0x30f9, 0x3775, 0x2a64, 0x396d, 0x3abd, + 0x3456, 0x38c5, 0x3401, 0x39c9, 0x3a3e, 0x35f5, 0x3b74, 0x305d, 0x3902, 0x33c5, 0x37b3, 0x38df, + 0x37ca, 0x2e80, 0x3200, 0x344c, 0x322b, 0x3914, 0x36a3, 0x3b76, 0x341f, 0x3a0b, 0x318c, 0x3a56, + 0x3656, 0x3b09, 0x362b, 0x3a98, 0x3b25, 0x393d, 0x3b19, 0x37df, 0x373c, 0x3a59, 0x366b, 0x3321, + 0x30d0, 0x399f, 0x3803, 0x3959, 0x2de4, 0x204c, 0x3881, 0x34bf, 0x3974, 0x3119, 0x3930, 0x3b63, + 0x34c4, 0x36ce, 0x3bef, 0x387d, 0x2c5e, 0x3170, 0x2d69, 0x398d, 0x3790, 0x3adc, 0x390e, 0x38e9, + 0x38f6, 0x3928, 0x35ea, 0x398c, 0x3a44, 0x3766, 0x34fc, 0x322d, 0x3812, 0x379d, 0x3ba0, 0x362e, + 0x30b1, 0x311f, 0x20a4, 0x3b23, 0x35ab, 0x3a53, 0x3bda, 0x39d7, 0x31a5, 0x3be9, 0x2bac, 0x39aa, + 0x3595, 0x3220, 0x3756, 0x3bdf, 0x331d, 0x3b09, 0x30b1, 0x3a28, 0x3a8b, 0x352f, 0x391e, 0x3a0d, + 0x327c, 0x3a9d, 0x312b, 0x3b5a, 0x3875, 0x3b68, 0x22ba, 0x33c5, 0x3a38, 0x291a, 0x313a, 0x3892, + 0x38f5, 0x3775, 0x34dc, 0x3b1b, 0x38ce, 0x31b8, 0x3aaa, 0x37dc, 0x2c05, 0x3a42, 0x3879, 0x3b0b, + 0x319e, 0x3a30, 0x33ed, 0x365a, 0x389e, 0x316c, 0x24f6, 0x389e, 0x3aa8, 0x351e, 0x31fd, 0x3986, + 0x39e3, 0x390f, 0x3b53, 0x39e2, 0x38bf, 0x393b, 0x3217, 0x39b1, 0x2c33, 0x3a61, 0x3897, 0x3af2, + 0x2c93, 0x3b6c, 0x34ef, 0x3b00, 0x349c, 0x3a3d, 0x3797, 0x3bf6, 0x3a52, 0x31b6, 0x342c, 0x3bb4, + 0x3aa1, 0x3537, 0x3aa1, 0x3776, 0x349e, 0x3860, 0x3670, 0x3b95, 0x3012, 0x38b5, 0x3991, 0x386a, + 0x3a23, 0x37b0, 0x3b7a, 0x3993, 0x39b1, 0x3146, 0x37a0, 0x25f0, 0x3652, 0x33b4, 0x31ee, 0x3446, + 0x3877, 0x3672, 0x35be, 0x3390, 0x330e, 0x3b03, 0x2f28, 0x2d4a, 0x3a78, 0x37ea, 0x3a0b, 0x3b47, + 0x3062, 0x3400, 0x34de, 0x37e1, 0x37e6, 0x245a, 0x2ae1, 0x3716, 0x35b8, 0x3949, 0x30a8, 0x39a7, + 0x3bc0, 0x29f2, 0x3641, 0x39b6, 0x31d1, 0x3ace, 0x3877, 0x32b8, 0x384b, 0x39ee, 0x38b7, 0x34ca, + 0x3a20, 0x3318, 0x3be5, 0x2823, 0x38cb, 0x34b5, 0x396a, 0x32ad, 0x3ad7, 0x3a41, 0x35fc, 0x3a63, + 0x30ad, 0x3825, 0x375b, 0x2c6e, 0x23c4, 0x3321, 0x2e54, 0x2c09, 0x329b, 0x330c, 0x2261, 0x3a04, + 0x384c, 0x36e4, 0x2d15, 0x36e5, 0x2d13, 0x302c, 0x37cd, 0x3a17, 0x3497, 0x3bd5, 0x3afb, 0x3654, + 0x3501, 0x3210, 0x377d, 0x38c8, 0x348e, 0x3412, 0x3648, 0x3bd7, 0x3a97, 0x2bd7, 0x36a6, 0x38c0, + 0x3736, 0x3a0b, 0x2e19, 0x3b13, 0x38a9, 0x3b43, 0x2c76, 0x3b01, 0x3863, 0x3a81, 0x2d37, 0x39fb, + 0x2ac8, 0x3590, 0x3bdc, 0x3bf7, 0x36d8, 0x33c7, 0x383e, 0x399c, 0x3482, 0x3325, 0x37d0, 0x3895, + 0x2211, 0x33c6, 0x3afd, 0x3968, 0x393b, 0x3814, 0x35e3, 0x3347, 0x35ee, 0x397e, 0x3b3c, 0x399e, + 0x35a7, 0x2929, 0x3ae2, 0x346a, 0x2ade, 0x3971, 0x3b81, 0x3af5, 0x343e, 0x39b0, 0x3aef, 0x38b7, + 0x3166, 0x3b3c, 0x3b52, 0x3af6, 0x3a28, 0x363f, 0x28a2, 0x3a83, 0x3b69, 0x2fb4, 0x3934, 0x371e, + 0x366f, 0x3754, 0x38c0, 0x3ba2, 0x3b87, 0x39a7, 0x32c6, 0x3027, 0x2969, 0x3415, 0x3a20, 0x3113, + 0x3abe, 0x3906, 0x27cc, 0x337f, 0x35ab, 0x31b7, 0x390f, 0x3900, 0x35a9, 0x3a0e, 0x34fa, 0x37bb, + 0x366e, 0x367e, 0x3948, 0x3afb, 0x36d9, 0x30a3, 0x3862, 0x2c6a, 0x39a8, 0x3a3c, 0x3574, 0x37bb, + 0x2d5c, 0x364b, 0x392e, 0x2c0c, 0x3539, 0x38cf, 0x3b4e, 0x3a54, 0x2ebf, 0x38c3, 0x358e, 0x394c, + 0x3a8d, 0x3ba8, 0x25cc, 0x3434, 0x2c2f, 0x39a3, 0x384f, 0x31a4, 0x3bbc, 0x2df2, 0x384d, 0x38cb, + 0x3b26, 0x3413, 0x38c9, 0x2e86, 0x30a5, 0x364e, 0x3b26, 0x3814, 0x31ef, 0x3272, 0x3ac8, 0x35b0, + 0x246f, 0x381c, 0x3755, 0x32bc, 0x358b, 0x35f4, 0x3767, 0x3a12, 0x3b09, 0x1270, 0x31d0, 0x389b, + 0x3661, 0x3971, 0x376f, 0x3921, 0x367d, 0x2524, 0x3ae6, 0x39d1, 0x3517, 0x3890, 0x380d, 0x362b, + 0x3944, 0x3792, 0x2df6, 0x30d7, 0x3bdb, 0x3918, 0x39e1, 0x3b27, 0x3bdb, 0x3bda, 0x3670, 0x3b9f, + 0x3566, 0x3690, 0x2686, 0x3335, 0x3856, 0x35ac, 0x3957, 0x397a, 0x32da, 0x38f3, 0x3765, 0x34a7, + 0x3a04, 0x361a, 0x3607, 0x38c0, 0x344a, 0x36b3, 0x3437, 0x3b66, 0x3a5a, 0x3909, 0x3455, 0x3530, + 0x36e1, 0x2e4a, 0x39f1, 0x3aa7, 0x3480, 0x3af5, 0x3786, 0x39e6, 0x36ee, 0x24ce, 0x39cb, 0x3450, + 0x3733, 0x3b77, 0x3be7, 0x3585, 0x3b30, 0x3994, 0x39df, 0x3a28, 0x3261, 0x35d5, 0x38a6, 0x391c, + 0x3bd0, 0x39db, 0x3470, 0x3a77, 0x3722, 0x37e9, 0x3851, 0x2f5a, 0x31d8, 0x39f6, 0x3618, 0x3bcc, + 0x2dc6, 0x39b1, 0x345c, 0x39a1, 0x3963, 0x3a6f, 0x39a6, 0x3541, 0x2d24, 0x39e8, 0x2e8e, 0x3439, + 0x2520, 0x38cc, 0x3a3a, 0x2ce2, 0x38f7, 0x389c, 0x3469, 0x389b, 0x32e2, 0x3a11, 0x34ec, 0x33af, + 0x3a1a, 0x3bcd, 0x27a3, 0x3b38, 0x2c62, 0x3b3d, 0x39cb, 0x1f85, 0x3576, 0x3a52, 0x3ad6, 0x3b42, + 0x39ad, 0x38db, 0x2e9a, 0x21d9, 0x3b72, 0x329c, 0x2cd8, 0x3688, 0x373b, 0x3599, 0x354d, 0x3b76, + 0x2260, 0x3903, 0x3be1, 0x36c1, 0x3b84, 0x3a9c, 0x342e, 0x3b05, 0x2d44, 0x3910, 0x3ab2, 0x3029, + 0x3b1e, 0x3827, 0x33e1, 0x3674, 0x3a80, 0x2f78, 0x38c1, 0x3ad1, 0x306c, 0x3942, 0x3a8c, 0x3847, + 0x3727, 0x37a0, 0x326f, 0x37a5, 0x2aa3, 0x2ec3, 0x3bef, 0x3a1c, 0x3914, 0x39c2, 0x3b4b, 0x2a9e, + 0x3bce, 0x39a3, 0x397f, 0x39d7, 0x34bd, 0x3956, 0x3717, 0x2daf, 0x3b73, 0x33b4, 0x3bb3, 0x38d7, + 0x372d, 0x344d, 0x2ceb, 0x2e98, 0x3509, 0x2d49, 0x3028, 0x34e0, 0x3681, 0x3734, 0x3be8, 0x31ed, + 0x35d7, 0x38a4, 0x3a92, 0x350a, 0x3a6c, 0x397c, 0x3bb4, 0x33d4, 0x3872, 0x3873, 0x2fb0, 0x395b, + 0x378a, 0x3a6b, 0x3a3f, 0x387a, 0x30ed, 0x39aa, 0x3854, 0x38b2, 0x3baa, 0x39ce, 0x3062, 0x3949, + 0x319c, 0x3816, 0x3764, 0x2c84, 0x3682, 0x3a71, 0x3596, 0x3afc, 0x37b8, 0x386d, 0x3a37, 0x2a1e, + 0x3845, 0x37ca, 0x3955, 0x380d, 0x355f, 0x3680, 0x3761, 0x358c, 0x3bbe, 0x2358, 0x381a, 0x31ec, + 0x2d29, 0x2746, 0x2c34, 0x3abe, 0x2f82, 0x39f0, 0x2c9b, 0x33a6, 0x381c, 0x3bc1, 0x3b81, 0x2f9a, + 0x3807, 0x2277, 0x38b2, 0x3210, 0x3b9f, 0x34ad, 0x3916, 0x30d3, 0x3a18, 0x39ac, 0x38a8, 0x3ba7, + 0x2bb8, 0x3a70, 0x33d8, 0x37b9, 0x38ee, 0x3510, 0x3874, 0x3be7, 0x3952, 0x35f5, 0x38d3, 0x3ba6, + 0x3452, 0x3401, 0x3819, 0x3beb, 0x3826, 0x3455, 0x3add, 0x2b23, 0x3590, 0x318e, 0x2d92, 0x3286, + 0x2d2b, 0x3225, 0x38bd, 0x36c4, 0x3b29, 0x2e2c, 0x3088, 0x3974, 0x3859, 0x3795, 0x3bd4, 0x2f4e, + 0x384a, 0x3ad9, 0x3aa7, 0x3448, 0x3736, 0x3b76, 0x3aac, 0x3959, 0x388b, 0x3a7f, 0x2b08, 0x29a3, + 0x29c4, 0x2412, 0x30b4, 0x3b6d, 0x3a1b, 0x3b86, 0x337b, 0x34e4, 0x32e0, 0x34df, 0x3750, 0x3a39, + 0x39f0, 0x39ed, 0x3a1a, 0x36d8, 0x3a40, 0x3b68, 0x388a, 0x2ce0, 0x3b16, 0x31ff, 0x3790, 0x35a3, + 0x3a17, 0x3b01, 0x3686, 0x39d9, 0x25a1, 0x3ade, 0x3073, 0x3753, 0x33c3, 0x381a, 0x2f26, 0x2e04, + 0x2dfb, 0x3779, 0x3813, 0x30a6, 0x3b85, 0x301a, 0x2f2c, 0x32b9, 0x38a5, 0x2fb3, 0x3bec, 0x39d9, + 0x3097, 0x3524, 0x3a92, 0x3b9c, 0x3a0b, 0x3492, 0x348b, 0x35a3, 0x3534, 0x3ae8, 0x39dc, 0x3b77, + 0x28c0, 0x3918, 0x3b4b, 0x3bc9, 0x3815, 0x373a, 0x3182, 0x35b7, 0x3906, 0x3b49, 0x32e0, 0x31c2, + 0x345a, 0x376b, 0x27ba, 0x283f, 0x38f4, 0x3ab3, 0x380a, 0x3a1a, 0x3b3e, 0x3aef, 0x39aa, 0x2c6c, + 0x2875, 0x3b82, 0x3bca, 0x36d6, 0x3833, 0x38f2, 0x30b8, 0x3b5d, 0x30e5, 0x201c, 0x3003, 0x373b, + 0x395f, 0x3b0f, 0x3af4, 0x3b88, 0x39d5, 0x3a2d, 0x2f53, 0x2b79, 0x32e4, 0x3830, 0x384a, 0x37f7, + 0x3a6a, 0x2eab, 0x3be0, 0x383d, 0x33ea, 0x33de, 0x38d0, 0x3112, 0x3ba3, 0x3034, 0x39fe, 0x37f5, + 0x39be, 0x3069, 0x3a87, 0x3134, 0x3b62, 0x37ee, 0x3a4b, 0x3744, 0x28e5, 0x2b0c, 0x3048, 0x3abf, + 0x3a79, 0x34d3, 0x3950, 0x3b57, 0x352c, 0x388b, 0x371c, 0x361f, 0x38f6, 0x3a5a, 0x34b4, 0x35e9, + 0x3afc, 0x3653, 0x33ae, 0x34d1, 0x3a4f, 0x3a8d, 0x35e2, 0x2c87, 0x2972, 0x337e, 0x3a72, 0x3120, + 0x368d, 0x33d8, 0x2694, 0x30f9, 0x3a90, 0x251a, 0x3074, 0x3ba7, 0x3a1c, 0x3a8e, 0x3953, 0x3900, + 0x3935, 0x3b52, 0x2ebd, 0x3b51, 0x33f7, 0x3876, 0x2782, 0x370a, 0x3134, 0x33fd, 0x3885, 0x3919, + 0x38a4, 0x3be0, 0x36a6, 0x34a3, 0x38c9, 0x3734, 0x3afb, 0x2ed7, 0x3691, 0x3212, 0x37e1, 0x36cf, + 0x3683, 0x391e, 0x3856, 0x3812, 0x3b0f, 0x3bd7, 0x3936, 0x3a5c, 0x3393, 0x3340, 0x3b9d, 0x30d6, + 0x37df, 0x3a62, 0x33c3, 0x3a3f, 0x3647, 0x3024, 0x3012, 0x378c, 0x3866, 0x35e9, 0x3bdf, 0x2521, + 0x3adf, 0x3991, 0x39ec, 0x2638, 0x31da, 0x3531, 0x386c, 0x32ae, 0x393d, 0x39be, 0x3827, 0x3071, + 0x3b2e, 0x36c1, 0x3748, 0x395d, 0x3812, 0x37b0, 0x349e, 0x3a46, 0x3a41, 0x37c9, 0x395f, 0x30cc, + 0x3068, 0x2a29, 0x38c6, 0x345d, 0x279c, 0x36d3, 0x38a0, 0x3965, 0x3838, 0x378e, 0x364f, 0x39f9, + 0x3a98, 0x32b1, 0x3444, 0x3be9, 0x39a7, 0x3520, 0x3823, 0x3afc, 0x3387, 0x3170, 0x38af, 0x2cc3, + 0x358b, 0x2e30, 0x3ac8, 0x3803, 0x36f6, 0x3747, 0x38a8, 0x3a9e, 0x211e, 0x3b13, 0x2cf0, 0x3a79, + 0x2c7e, 0x3786, 0x3521, 0x2e6a, 0x3714, 0x356a, 0x2ce9, 0x3879, 0x3855, 0x3662, 0x305b, 0x3915, + 0x2e38, 0x3870, 0x3673, 0x33fd, 0x3bb6, 0x2d86, 0x2934, 0x372f, 0x2ac0, 0x368d, 0x3595, 0x32db, + 0x39a1, 0x3161, 0x359a, 0x37dd, 0x344b, 0x36fa, 0x3af1, 0x2a7d, 0x310d, 0x3a46, 0x358b, 0x39fb, + 0x3580, 0x3b84, 0x2a21, 0x3aba, 0x3ab3, 0x3947, 0x3130, 0x3056, 0x3ac0, 0x35c0, 0x3b0d, 0x3b5d, + 0x3922, 0x3696, 0x3b40, 0x38de, 0x38eb, 0x36f1, 0x36fa, 0x334e, 0x347a, 0x3840, 0x2435, 0x3409, + 0x3a1d, 0x3a86, 0x3990, 0x32a5, 0x3908, 0x362b, 0x2600, 0x39ad, 0x3b1a, 0x3add, 0x3b3d, 0x3ad3, + 0x381d, 0x314a, 0x3a33, 0x3837, 0x3b5c, 0x3a79, 0x286c, 0x382d, 0x3209, 0x38c9, 0x3a4c, 0x3b36, + 0x3012, 0x36cb, 0x3845, 0x385c, 0x3756, 0x3542, 0x3669, 0x3a4e, 0x3bc4, 0x2c70, 0x21bf, 0x36d5, + 0x39dc, 0x2e49, 0x35e7, 0x3be7, 0x30dd, 0x3384, 0x2877, 0x3bce, 0x395a, 0x344d, 0x38d6, 0x34a5, + 0x245c, 0x382e, 0x3065, 0x3b3c, 0x3504, 0x3809, 0x38b8, 0x37b4, 0x3467, 0x3a8e, 0x39bd, 0x390b, + 0x3ac2, 0x3990, 0x3aeb, 0x38b0, 0x39b2, 0x3852, 0x39a8, 0x2c6d, 0x399b, 0x27d9, 0x3704, 0x39fd, + 0x365e, 0x3610, 0x367a, 0x345e, 0x3acd, 0x38b2, 0x3a36, 0x3221, 0x36e1, 0x3800, 0x352e, 0x3bfe, + 0x381b, 0x3a6b, 0x38b6, 0x3a36, 0x320b, 0x3971, 0x31a8, 0x3bfc, 0x199c, 0x3a89, 0x3b46, 0x38dd, + 0x3560, 0x3408, 0x3af5, 0x3b03, 0x3a6e, 0x3778, 0x389c, 0x30f4, 0x3624, 0x2d25, 0x36f1, 0x393f, + 0x26ce, 0x3993, 0x374b, 0x3bfc, 0x3b34, 0x3b9f, 0x259a, 0x355d, 0x389a, 0x3468, 0x3950, 0x385b, + 0x3b0b, 0x3851, 0x37fa, 0x394e, 0x3564, 0x344e, 0x390c, 0x38a2, 0x2cd0, 0x340f, 0x312b, 0x396c, + 0x351e, 0x3a7a, 0x3124, 0x332a, 0x3a4d, 0x33b8, 0x36f9, 0x2f22, 0x39b8, 0x3b4d, 0x3ae7, 0x39bd, + 0x396d, 0x3b7f, 0x301a, 0x30e2, 0x2d27, 0x3b5d, 0x3b02, 0x3be2, 0x3289, 0x393e, 0x36cc, 0x37e9, + 0x29ba, 0x3927, 0x35fb, 0x2e26, 0x38fd, 0x310c, 0x3bd7, 0x2cc9, 0x39ab, 0x3be4, 0x3515, 0x3949, + 0x35e7, 0x3643, 0x38d5, 0x3981, 0x3937, 0x3be6, 0x2fb2, 0x392c, 0x348c, 0x38f2, 0x3872, 0x3b6b, + 0x3ae0, 0x39a3, 0x3959, 0x3555, 0x3329, 0x35dd, 0x38ac, 0x3530, 0x39af, 0x2ef5, 0x28c1, 0x39d1, + 0x3bc1, 0x34be, 0x3b5d, 0x328b, 0x32b2, 0x3872, 0x3bd4, 0x3b03, 0x2e0f, 0x39d4, 0x3925, 0x3770, + 0x3a7d, 0x28c2, 0x38a1, 0x3874, 0x3b11, 0x3b64, 0x371e, 0x3600, 0x379a, 0x3bb9, 0x35ca, 0x32ad, + 0x3b2d, 0x349b, 0x36f2, 0x374c, 0x38c9, 0x34d0, 0x34b4, 0x35bb, 0x3a16, 0x33b5, 0x3209, 0x3500, + 0x3ae0, 0x3721, 0x34ee, 0x351b, 0x3bc5, 0x3878, 0x31f0, 0x34b7, 0x318a, 0x3b29, 0x2ddc, 0x36f4, + 0x3b04, 0x3844, 0x3afe, 0x34b9, 0x31a0, 0x3aa8, 0x277e, 0x3b2d, 0x3545, 0x39f3, 0x2d07, 0x2f39, + 0x3803, 0x1c7e, 0x364e, 0x3a54, 0x328b, 0x3772, 0x3907, 0x3951, 0x365f, 0x3b93, 0x3acd, 0x30e7, + 0x298a, 0x2bcc, 0x3b9a, 0x3a54, 0x365d, 0x3b01, 0x3ab5, 0x2f7f, 0x304b, 0x3257, 0x39bf, 0x3b2e, + 0x390c, 0x3802, 0x3a0d, 0x37d7, 0x338c, 0x3a35, 0x3bd1, 0x3905, 0x3be8, 0x3ab3, 0x388c, 0x2d83, + 0x3b83, 0x32ef, 0x359a, 0x35bb, 0x38e2, 0x3813, 0x3419, 0x384f, 0x3606, 0x3825, 0x38ed, 0x3927, + 0x3407, 0x3aad, 0x34f3, 0x3b8e, 0x36d6, 0x3599, 0x3502, 0x3b90, 0x38b2, 0x2f9d, 0x3bd0, 0x32ab, + 0x3629, 0x3ad2, 0x342d, 0x25db, 0x3786, 0x3a93, 0x3823, 0x3320, 0x3a21, 0x387f, 0x38df, 0x3134, + 0x3743, 0x3b35, 0x37fc, 0x3a9c, 0x2778, 0x3b7d, 0x2c40, 0x37f6, 0x39db, 0x3ab3, 0x3537, 0x34bd, + 0x3865, 0x3a8f, 0x3a3d, 0x201e, 0x3a9c, 0x3956, 0x2ce1, 0x3bd8, 0x2856, 0x3876, 0x38b5, 0x296a, + 0x3226, 0x3a4d, 0x39ee, 0x3bed, 0x39d8, 0x3527, 0x374d, 0x3acc, 0x3bef, 0x30a0, 0x3124, 0x325d, + 0x32e4, 0x38d8, 0x3988, 0x3b3e, 0x340d, 0x3a1c, 0x383d, 0x2e36, 0x3874, 0x36f1, 0x3758, 0x2e80, + 0x3422, 0x3408, 0x3727, 0x3234, 0x2e0e, 0x3b7a, 0x3a16, 0x3868, 0x33e8, 0x3918, 0x2fc1, 0x2d27, + 0x36b4, 0x3b19, 0x3489, 0x391e, 0x3a54, 0x3bc8, 0x3bbb, 0x3861, 0x3985, 0x396c, 0x335a, 0x3a9a, + 0x36ae, 0x3484, 0x3b9d, 0x3874, 0x3283, 0x357f, 0x37ae, 0x387b, 0x2a12, 0x3436, 0x2c10, 0x3bff, + 0x3baf, 0x2d43, 0x35f8, 0x3a9e, 0x3ad3, 0x35f3, 0x3569, 0x2884, 0x384a, 0x39ea, 0x3afa, 0x3987, + 0x3b65, 0x3b3b, 0x37a0, 0x25cb, 0x3be9, 0x3217, 0x34c0, 0x2822, 0x34dc, 0x3b46, 0x3498, 0x392d, + 0x35d8, 0x39b7, 0x39c0, 0x334d, 0x354e, 0x3861, 0x3486, 0x3739, 0x3ab8, 0x2d46, 0x384d, 0x3b21, + 0x3b3e, 0x3025, 0x38ec, 0x27a0, 0x3879, 0x39bd, 0x36e4, 0x3677, 0x3bb5, 0x3966, 0x3921, 0x3a5b, + 0x30e8, 0x37ab, 0x3a1f, 0x33a7, 0x345a, 0x3457, 0x3223, 0x39e7, 0x3733, 0x37df, 0x39cc, 0x2612, + 0x355c, 0x36e9, 0x3adf, 0x3aa6, 0x39d4, 0x32da, 0x3983, 0x3456, 0x2eff, 0x32be, 0x39f0, 0x39a7, + 0x349d, 0x3a15, 0x38c8, 0x32dc, 0x3a4f, 0x3272, 0x22cf, 0x3a8a, 0x2ad2, 0x2ea8, 0x37ec, 0x31fa, + 0x3645, 0x399b, 0x3835, 0x32e0, 0x359d, 0x38f3, 0x3b1d, 0x3a60, 0x33fd, 0x3910, 0x373f, 0x3bb0, + 0x39c9, 0x3144, 0x3b20, 0x363b, 0x36d3, 0x2810, 0x341f, 0x385a, 0x38d9, 0x3924, 0x399a, 0x33b3, + 0x3bca, 0x39ca, 0x349e, 0x35ed, 0x3244, 0x37e1, 0x3887, 0x3873, 0x3ab0, 0x3b9e, 0x3961, 0x3471, + 0x3afb, 0x3ba7, 0x3778, 0x36c5, 0x3a15, 0x398d, 0x336b, 0x367a, 0x3bff, 0x382c, 0x34bd, 0x39e5, + 0x37d2, 0x3a38, 0x361c, 0x32bc, 0x38bc, 0x2d3a, 0x3559, 0x3ad2, 0x38ba, 0x3bd0, 0x3ab3, 0x331e, + 0x3891, 0x381b, 0x324f, 0x2d22, 0x38c7, 0x3577, 0x377b, 0x38ae, 0x38f8, 0x36f7, 0x3911, 0x28fc, + 0x36a7, 0x3658, 0x37d8, 0x3ab1, 0x3b8d, 0x32e6, 0x34bf, 0x34cb, 0x3bd5, 0x2cba, 0x382e, 0x30d2, + 0x355e, 0x391e, 0x385e, 0x3ab4, 0x397a, 0x304f, 0x3af3, 0x390e, 0x3646, 0x3624, 0x39cc, 0x3aef, + 0x3817, 0x3524, 0x34b2, 0x39f7, 0x393b, 0x32ed, 0x3af8, 0x3229, 0x3975, 0x3786, 0x3346, 0x37db, + 0x2bd4, 0x3481, 0x3a60, 0x393e, 0x3ad6, 0x3479, 0x3434, 0x321c, 0x3995, 0x3511, 0x2047, 0x34c2, + 0x3946, 0x3900, 0x356f, 0x3485, 0x3b9a, 0x3b68, 0x3482, 0x3850, 0x3539, 0x37e7, 0x3bb5, 0x2c92, + 0x1c36, 0x3617, 0x3abf, 0x36f8, 0x3ad6, 0x3451, 0x29fb, 0x3a36, 0x37d3, 0x2b19, 0x3a12, 0x3a0f, + 0x3207, 0x3857, 0x3a80, 0x3ac0, 0x38eb, 0x30dc, 0x34c2, 0x3b55, 0x3a9b, 0x391f, 0x2bfa, 0x39b1, + 0x381c, 0x3855, 0x3999, 0x384a, 0x3baf, 0x389c, 0x32e3, 0x3bd8, 0x2e14, 0x363c, 0x3a87, 0x3237, + 0x33e4, 0x3bcf, 0x3a55, 0x3959, 0x3482, 0x3af7, 0x3b2a, 0x396d, 0x3adb, 0x347c, 0x3a36, 0x3800, + 0x3b48, 0x3a7c, 0x3a55, 0x36f0, 0x3955, 0x3230, 0x3648, 0x3087, 0x3426, 0x314d, 0x3a35, 0x3874, + 0x3861, 0x388d, 0x32c7, 0x3966, 0x341a, 0x302f, 0x2ef8, 0x3793, 0x37e9, 0x3a68, 0x3345, 0x3952, + 0x2ef3, 0x35c0, 0x3a6b, 0x3b79, 0x3887, 0x383a, 0x3b55, 0x3834, 0x39d0, 0x3724, 0x3ad1, 0x33da, + 0x3765, 0x3474, 0x39ce, 0x3529, 0x39c1, 0x3b00, 0x3902, 0x357d, 0x357e, 0x3709, 0x2dac, 0x3468, + 0x37fa, 0x342a, 0x3af0, 0x378b, 0x39f9, 0x2996, 0x33af, 0x395b, 0x391d, 0x39e1, 0x2d27, 0x2c5c, + 0x32d1, 0x3996, 0x3794, 0x314e, 0x3960, 0x3aea, 0x3b05, 0x3b28, 0x3860, 0x3950, 0x29d6, 0x24e0, + 0x360c, 0x391a, 0x32f6, 0x3897, 0x39b6, 0x34cd, 0x3416, 0x30b2, 0x3467, 0x3699, 0x3a59, 0x28dd, + 0x37f1, 0x34fa, 0x3b2e, 0x37e6, 0x3b52, 0x3bae, 0x25dd, 0x351f, 0x2f17, 0x36cd, 0x3bfd, 0x39f0, + 0x38d8, 0x3945, 0x38a9, 0x35cb, 0x3a1b, 0x37fe, 0x3458, 0x3b2e, 0x3b34, 0x36a2, 0x1937, 0x3b9b, + 0x3602, 0x36dd, 0x2f99, 0x3b91, 0x37b6, 0x3b68, 0x3375, 0x3998, 0x30cf, 0x385e, 0x356e, 0x3a0b, + 0x3026, 0x3010, 0x388c, 0x3be2, 0x3a80, 0x3765, 0x3a88, 0x398d, 0x37fc, 0x3a63, 0x3a73, 0x38b3, + 0x30cb, 0x3414, 0x3478, 0x37f8, 0x2ac0, 0x3711, 0x3851, 0x3abb, 0x3a7b, 0x38fe, 0x3810, 0x3af1, + 0x3af5, 0x3a93, 0x394b, 0x331a, 0x3751, 0x362f, 0x36d0, 0x212b, 0x3b8d, 0x3969, 0x396b, 0x3570, + 0x38a4, 0x316a, 0x3273, 0x2dfe, 0x3652, 0x3ab5, 0x3bae, 0x26c9, 0x3aa2, 0x33d1, 0x3453, 0x3664, + 0x2bf6, 0x38a9, 0x3b51, 0x3593, 0x3a83, 0x3822, 0x2846, 0x3a65, 0x3814, 0x37e8, 0x39a3, 0x3925, + 0x3acf, 0x252b, 0x3882, 0x3b04, 0x3240, 0x398b, 0x2b29, 0x35a2, 0x1eb4, 0x375f, 0x363e, 0x3461, + 0x3469, 0x308e, 0x360d, 0x3ab2, 0x3aa4, 0x396f, 0x2ed3, 0x30ec, 0x38a8, 0x389f, 0x3211, 0x35c6, + 0x390e, 0x3bf3, 0x389e, 0x3bc8, 0x3b0e, 0x3942, 0x3866, 0x379d, 0x3858, 0x2d3f, 0x2766, 0x34a0, + 0x326c, 0x383c, 0x367b, 0x2759, 0x368f, 0x3451, 0x3b18, 0x39e6, 0x320c, 0x354d, 0x3ab1, 0x382e, + 0x381f, 0x38af, 0x3a12, 0x3aaa, 0x396f, 0x3a24, 0x287c, 0x3bd7, 0x3483, 0x388b, 0x343d, 0x3b0e, + 0x347f, 0x3964, 0x2a65, 0x36bc, 0x3780, 0x37ae, 0x38f6, 0x31f7, 0x373c, 0x3817, 0x3079, 0x3552, + 0x2f93, 0x3753, 0x3972, 0x3882, 0x3b1a, 0x39fd, 0x3855, 0x3967, 0x2fc4, 0x3a87, 0x3a46, 0x385e, + 0x3a6f, 0x3651, 0x3808, 0x363b, 0x2d10, 0x3b99, 0x3aec, 0x3a80, 0x3825, 0x3865, 0x3629, 0x37b8, + 0x3b96, 0x3159, 0x3b17, 0x3506, 0x35c8, 0x363e, 0x3411, 0x30bf, 0x380c, 0x3673, 0x342a, 0x2bd6, + 0x33c5, 0x28af, 0x39eb, 0x3ad1, 0x3b69, 0x3b4a, 0x38d6, 0x379f, 0x3b24, 0x352e, 0x3578, 0x3bbe, + 0x3a1c, 0x28ac, 0x387a, 0x2924, 0x38fe, 0x3878, 0x3960, 0x396a, 0x34c3, 0x3738, 0x34e3, 0x3676, + 0x3221, 0x303f, 0x31b2, 0x3256, 0x34b2, 0x3673, 0x39c4, 0x3a82, 0x3b83, 0x3967, 0x3890, 0x3892, + 0x2c28, 0x3241, 0x39cd, 0x399e, 0x354c, 0x28cd, 0x2e5b, 0x38b5, 0x30bc, 0x390e, 0x38e8, 0x2ffe, + 0x3bb3, 0x2481, 0x3b10, 0x3b1e, 0x2ff2, 0x38cf, 0x3a0b, 0x3b90, 0x391d, 0x35ba, 0x38d1, 0x3b7a, + 0x35fc, 0x37b3, 0x3b7f, 0x3abf, 0x3647, 0x3058, 0x396f, 0x3249, 0x3880, 0x389b, 0x3aa2, 0x2aa2, + 0x3ad4, 0x36e1, 0x380d, 0x383c, 0x363f, 0x32d3, 0x3873, 0x3912, 0x34a0, 0x388b, 0x36eb, 0x3816, + 0x3adf, 0x3684, 0x36a7, 0x3094, 0x35ff, 0x3044, 0x3a50, 0x3b4e, 0x3894, 0x3b93, 0x33ce, 0x3ae0, + 0x3ab4, 0x2d37, 0x34cf, 0x3946, 0x370c, 0x3ad4, 0x3a2c, 0x3bc8, 0x3b07, 0x3a73, 0x38d1, 0x39bf, + 0x30bd, 0x3a04, 0x384e, 0x3b26, 0x356f, 0x32fe, 0x38e5, 0x3856, 0x3046, 0x3b4e, 0x2cd0, 0x345a, + 0x2464, 0x3bad, 0x2d72, 0x32da, 0x3783, 0x3595, 0x306a, 0x3a93, 0x3851, 0x3807, 0x2e73, 0x386c, + 0x2f53, 0x3b57, 0x2fb5, 0x238d, 0x358d, 0x3684, 0x3b79, 0x3538, 0x368b, 0x3914, 0x3aaf, 0x358b, + 0x2c1c, 0x37b5, 0x3a1e, 0x3bc5, 0x346c, 0x3bf6, 0x330e, 0x3459, 0x374b, 0x3b9d, 0x2841, 0x3696, + 0x33c3, 0x3845, 0x3860, 0x3a21, 0x3176, 0x3b70, 0x31f1, 0x3a89, 0x35d2, 0x2d6e, 0x3a3d, 0x3b9b, + 0x3aac, 0x39c9, 0x36ec, 0x3a46, 0x3507, 0x3606, 0x347c, 0x3626, 0x3b6b, 0x38db, 0x2e3f, 0x3a61, + 0x39c8, 0x3185, 0x284a, 0x3027, 0x35b8, 0x3978, 0x2fd0, 0x3989, 0x2e44, 0x2f35, 0x34ed, 0x392b, + 0x3202, 0x39b3, 0x3a9c, 0x3b9b, 0x2c42, 0x301c, 0x33de, 0x270a, 0x33ab, 0x3bd8, 0x3bac, 0x3136, + 0x3b9f, 0x38d2, 0x3977, 0x32ad, 0x2e75, 0x310e, 0x36e3, 0x3200, 0x376b, 0x38ca, 0x39f9, 0x39ca, + 0x3b9b, 0x3236, 0x3969, 0x3b8e, 0x3345, 0x3b34, 0x3817, 0x387e, 0x38e6, 0x3b46, 0x3417, 0x3b14, + 0x3b0c, 0x3bc2, 0x3a2b, 0x3781, 0x32a7, 0x3a3d, 0x35a6, 0x3b34, 0x388f, 0x348e, 0x3a2f, 0x397c, + 0x39f7, 0x32f5, 0x2cda, 0x38ea, 0x3a85, 0x3883, 0x3996, 0x288d, 0x3a3e, 0x34cf, 0x3bbd, 0x3ae5, + 0x232d, 0x2c50, 0x2e6f, 0x3bd4, 0x3a52, 0x2f61, 0x38f1, 0x3970, 0x375c, 0x39e0, 0x3821, 0x3ad0, + 0x3994, 0x38e5, 0x3b02, 0x36bc, 0x388d, 0x3654, 0x364b, 0x3a55, 0x3739, 0x2cfc, 0x3879, 0x3299, + 0x39ba, 0x3a0c, 0x3b90, 0x34cb, 0x389a, 0x39bd, 0x3531, 0x381d, 0x3897, 0x3bc3, 0x35da, 0x3709, + 0x35b2, 0x36c4, 0x3614, 0x3906, 0x3939, 0x3a65, 0x3b03, 0x3a79, 0x348c, 0x3af4, 0x2ff0, 0x3ab5, + 0x2402, 0x38d8, 0x3861, 0x2e1c, 0x242f, 0x3b2f, 0x3bd7, 0x3a99, 0x3969, 0x3897, 0x326f, 0x2cd4, + 0x389b, 0x39dd, 0x384b, 0x35d9, 0x367f, 0x3821, 0x3ab8, 0x3a10, 0x3bc5, 0x3588, 0x3b33, 0x39cc, + 0x3a90, 0x39a7, 0x360a, 0x2cb2, 0x3aa2, 0x3aae, 0x313c, 0x3b1e, 0x3b0d, 0x3b3f, 0x3031, 0x29f6, + 0x3a0b, 0x36ae, 0x3116, 0x2954, 0x3836, 0x357b, 0x3a21, 0x391b, 0x3b74, 0x3456, 0x34b5, 0x3bdf, + 0x365c, 0x35a4, 0x371c, 0x3926, 0x39d2, 0x2eed, 0x38a1, 0x2f2b, 0x3a03, 0x36f7, 0x3a86, 0x3794, + 0x33d3, 0x2f4d, 0x39b0, 0x2eb4, 0x3962, 0x3972, 0x3685, 0x3ab4, 0x39e9, 0x38a1, 0x3ba8, 0x22a7, + 0x307f, 0x3947, 0x35bd, 0x2c44, 0x3b47, 0x306d, 0x3807, 0x3937, 0x3925, 0x38f3, 0x2825, 0x387d, + 0x3bec, 0x2ece, 0x3617, 0x390e, 0x34a8, 0x3892, 0x3b1f, 0x37b9, 0x15a5, 0x3195, 0x3814, 0x3972, + 0x2d39, 0x39f1, 0x2d4b, 0x38cf, 0x34c4, 0x315c, 0x3a67, 0x349f, 0x3bf5, 0x3620, 0x346b, 0x3133, + 0x2870, 0x3647, 0x265d, 0x3a20, 0x3878, 0x20b6, 0x252d, 0x3408, 0x20e5, 0x3a58, 0x372d, 0x38b8, + 0x3983, 0x387b, 0x3296, 0x3b9f, 0x39b8, 0x39f1, 0x3445, 0x393c, 0x3886, 0x3bbc, 0x3944, 0x343e, + 0x2dbd, 0x36d8, 0x392e, 0x386e, 0x3a3b, 0x3bde, 0x3be4, 0x35e6, 0x39aa, 0x30d6, 0x32fd, 0x2e3c, + 0x3bab, 0x388f, 0x381c, 0x3b43, 0x2b51, 0x3b44, 0x3ab3, 0x2c11, 0x2c53, 0x3810, 0x3b94, 0x3aa5, + 0x3a30, 0x2e27, 0x308f, 0x37a4, 0x36ff, 0x3b77, 0x2c32, 0x3b31, 0x3903, 0x2dcb, 0x3284, 0x3b60, + 0x31c4, 0x2f13, 0x398c, 0x3b20, 0x34d1, 0x32da, 0x3917, 0x37a0, 0x398e, 0x32ac, 0x3b17, 0x39c8, + 0x32af, 0x3225, 0x34f8, 0x325d, 0x2cbd, 0x3578, 0x3919, 0x2c55, 0x38a8, 0x3a4c, 0x35ed, 0x38f6, + 0x39b5, 0x3261, 0x31b3, 0x3b23, 0x3956, 0x332d, 0x38d9, 0x30cb, 0x360a, 0x39f3, 0x39b6, 0x393b, + 0x3977, 0x39f2, 0x332b, 0x3a15, 0x390b, 0x3a7f, 0x36ac, 0x3403, 0x34ee, 0x39eb, 0x3977, 0x304c, + 0x3922, 0x31dd, 0x377c, 0x2dcd, 0x39d1, 0x3915, 0x3a55, 0x358b, 0x2c1e, 0x365f, 0x3597, 0x296f, + 0x3514, 0x31e1, 0x2f8a, 0x3ba3, 0x3a51, 0x3965, 0x2a31, 0x38c7, 0x3930, 0x327b, 0x382d, 0x351c, + 0x3164, 0x38a4, 0x33f7, 0x24d9, 0x3799, 0x32e4, 0x3a10, 0x3959, 0x3802, 0x385c, 0x307f, 0x2860, + 0x3632, 0x36a5, 0x3a8e, 0x3941, 0x3b83, 0x3a6b, 0x3096, 0x3112, 0x35c0, 0x3a0c, 0x3909, 0x3a75, + 0x386e, 0x38bd, 0x34b7, 0x37a4, 0x3116, 0x3b05, 0x302a, 0x392a, 0x3535, 0x3416, 0x38b4, 0x3910, + 0x3385, 0x3bc4, 0x3403, 0x35d9, 0x3058, 0x3694, 0x3aa1, 0x2c56, 0x3458, 0x3475, 0x3bbc, 0x25ea, + 0x349b, 0x3883, 0x3b41, 0x2832, 0x30dc, 0x39c6, 0x3be4, 0x2f05, 0x3a4d, 0x3748, 0x380b, 0x213e, + 0x38fe, 0x3648, 0x38cc, 0x3727, 0x375f, 0x332f, 0x3989, 0x3849, 0x3b12, 0x333c, 0x3a5f, 0x295e, + 0x326b, 0x38ac, 0x30b4, 0x396d, 0x3a8f, 0x254c, 0x39c2, 0x2823, 0x3740, 0x3556, 0x220b, 0x35dd, + 0x3af9, 0x38b8, 0x3a94, 0x2f27, 0x340e, 0x3486, 0x319a, 0x3bbd, 0x39d7, 0x39e7, 0x379d, 0x3aa4, + 0x3875, 0x3aec, 0x3b96, 0x3bcd, 0x3743, 0x39c7, 0x3a3b, 0x338a, 0x3979, 0x35b0, 0x3940, 0x3bd6, + 0x33f0, 0x368a, 0x39af, 0x33f8, 0x3bef, 0x3b15, 0x3077, 0x344a, 0x3a58, 0x3a8c, 0x3486, 0x3b0d, + 0x3b0f, 0x36b2, 0x3a93, 0x3b42, 0x3561, 0x3a29, 0x34de, 0x37c3, 0x39a1, 0x392f, 0x3b6c, 0x369f}; + +uint16_t w_inp[N_SIZE * K_SIZE] = { + 0x3bbf, 0x3a4f, 0x38c4, 0x327f, 0x39bf, 0x3b69, 0x39a3, 0x2e11, 0x38e6, 0x3c00, 0x3ae7, 0x1823, + 0x3bfe, 0x3a16, 0x3b13, 0x3208, 0x3355, 0x38fb, 0x39f1, 0x3644, 0x38ea, 0x3ba0, 0x32f9, 0x2c66, + 0x2fa4, 0x162a, 0x30f9, 0x284c, 0x38ba, 0x3922, 0x36ba, 0x3299, 0x3729, 0x3a1d, 0x3593, 0x3526, + 0x3974, 0x3ae1, 0x3901, 0x3bdf, 0x35eb, 0x3986, 0x39a7, 0x23a9, 0x38ac, 0x3013, 0x2e9f, 0x37e7, + 0x3879, 0x3507, 0x3b76, 0x2fa5, 0x3b21, 0x3b63, 0x3af5, 0x39de, 0x31cb, 0x3757, 0x3409, 0x3b56, + 0x396c, 0x30ea, 0x2837, 0x39a6, 0x30bd, 0x3bb3, 0x3ad3, 0x3b51, 0x36bf, 0x34f2, 0x32cf, 0x39a2, + 0x3a21, 0x38d6, 0x246c, 0x3553, 0x2a8d, 0x39f9, 0x31a6, 0x3bff, 0x3570, 0x3630, 0x39a3, 0x266e, + 0x3a7e, 0x300e, 0x2ee0, 0x333d, 0x3753, 0x3a04, 0x3a4e, 0x38ed, 0x397a, 0x3b7a, 0x3a68, 0x36b5, + 0x2e7c, 0x3b1b, 0x393d, 0x3802, 0x3820, 0x2585, 0x328c, 0x3a63, 0x38e6, 0x3b34, 0x3396, 0x3714, + 0x324b, 0x35e4, 0x367c, 0x39a7, 0x36ef, 0x3b36, 0x39e2, 0x3871, 0x3bb2, 0x3901, 0x37af, 0x3b38, + 0x352a, 0x39c0, 0x3446, 0x313d, 0x34ad, 0x37a4, 0x386d, 0x3433, 0x3aa4, 0x396e, 0x3902, 0x380b, + 0x3197, 0x3238, 0x3552, 0x3885, 0x3b50, 0x39a3, 0x3b07, 0x2d7f, 0x3631, 0x3a74, 0x389d, 0x31d4, + 0x3b0e, 0x301e, 0x38a7, 0x3c00, 0x86e, 0x357e, 0x33e0, 0x3519, 0x39ad, 0x3b27, 0x3841, 0x3ba6, + 0x39fc, 0x3903, 0x3850, 0x398a, 0x39dd, 0x3837, 0x35f1, 0x34b0, 0x33d4, 0x3bde, 0x3013, 0x2f51, + 0x3b18, 0x37ed, 0x3517, 0x3b3e, 0x3a88, 0x3a1a, 0x3203, 0x370b, 0x3994, 0x3a22, 0x29e5, 0x38af, + 0x354b, 0x2862, 0x3204, 0x3483, 0x3b73, 0x3732, 0x3a46, 0x3455, 0x36c9, 0x3450, 0x35c2, 0x3582, + 0x3862, 0x3b2e, 0x3422, 0x38a7, 0x3275, 0x351c, 0x35f2, 0x39d6, 0x3453, 0x381c, 0x3a47, 0x3acd, + 0x38bf, 0x3a66, 0x33b9, 0x31e4, 0x350d, 0x3be2, 0x38b9, 0x37ac, 0x24dc, 0x2ec2, 0x3239, 0x3546, + 0x3b1f, 0x3404, 0x3a82, 0x377c, 0x34d0, 0x34a4, 0x3b4e, 0x398d, 0x3992, 0x32f9, 0x3957, 0x3810, + 0x3bc4, 0x38bd, 0x3b31, 0x2d86, 0x3519, 0x3a4f, 0x398a, 0x39cf, 0x3b0d, 0x326a, 0x367f, 0x3a57, + 0x39b7, 0x3b13, 0x37b7, 0x38e9, 0x3774, 0x2cf1, 0x36cf, 0x3a0d, 0x38ba, 0x2b93, 0x37d2, 0x2c24, + 0x35cf, 0x377c, 0x32c3, 0x3a7c, 0x3b6f, 0x353a, 0x3046, 0x3601, 0x3597, 0x2b40, 0x3893, 0x3be2, + 0x298d, 0x2e2c, 0x3907, 0x2a90, 0x3498, 0x3bed, 0x3469, 0x3080, 0x30ae, 0x35d8, 0x3814, 0x3529, + 0x3912, 0x3a96, 0x33b6, 0x3405, 0x38d4, 0x3936, 0x31ba, 0x348e, 0x2c03, 0x34f7, 0x3995, 0x396f, + 0x31d7, 0x396d, 0x2c71, 0x39aa, 0x32ef, 0x397e, 0x1592, 0x3830, 0x3ad8, 0x3872, 0x35d2, 0x3b2c, + 0x309b, 0x35c0, 0x35d6, 0x35e1, 0x3bbe, 0x375d, 0x3974, 0x3a7e, 0x3ab8, 0x3534, 0x3966, 0x37d2, + 0x3515, 0x25c9, 0x35c6, 0x3788, 0x3734, 0x3aa6, 0x33d7, 0x395e, 0x35bc, 0x3b47, 0x39f3, 0x3a5b, + 0x38e0, 0x3161, 0x2913, 0x39eb, 0x398e, 0x32cf, 0x3800, 0x35b4, 0x3a4f, 0x3aa5, 0x3a05, 0x3404, + 0x3a87, 0x3ba6, 0x3afa, 0x35ac, 0x3bad, 0x3906, 0x332e, 0x3a85, 0x3b6a, 0x30fc, 0x300c, 0x3861, + 0x36f6, 0x3acd, 0x34ff, 0x3882, 0x362d, 0x39fc, 0x3b5d, 0x283f, 0x3af2, 0x3bfe, 0x381e, 0x3b54, + 0x395b, 0x35fc, 0x3a7c, 0x3a03, 0x372f, 0x342d, 0x3846, 0x3922, 0x39b9, 0x3523, 0x3998, 0x3568, + 0x3662, 0x2c52, 0x3982, 0x2e41, 0x37d6, 0x38cd, 0x3b9e, 0x37cc, 0x2e33, 0x2f92, 0x3a44, 0x3b79, + 0x3b2e, 0x39c9, 0x3683, 0x300a, 0x3a4b, 0x25da, 0x3351, 0x3920, 0x34b3, 0x3314, 0x3905, 0x1ed4, + 0x39bc, 0x3b3e, 0x3950, 0x359e, 0x36da, 0x35a7, 0x39da, 0x389d, 0x3976, 0x3860, 0x369f, 0x3a0f, + 0x3620, 0x33c8, 0x3a2a, 0x3776, 0x344a, 0x3a2e, 0x325e, 0x3852, 0x2e84, 0x31eb, 0x3474, 0x393b, + 0x3225, 0x2d3a, 0x3870, 0x2229, 0x3469, 0x33fa, 0x31bd, 0x3055, 0x3a42, 0x381a, 0x3ab9, 0x39d2, + 0x384a, 0x35f4, 0x32fe, 0x305e, 0x317e, 0x3484, 0x308b, 0x3893, 0x39e1, 0x3a15, 0x38a6, 0x3321, + 0x376a, 0x39c9, 0x317f, 0x37a6, 0x30e6, 0x3362, 0x37ac, 0x389b, 0x3818, 0x3883, 0x354b, 0x3b88, + 0x39d8, 0x3a60, 0x375b, 0x3836, 0x38cc, 0x37fb, 0x3927, 0x3b78, 0x3961, 0x39b7, 0x302d, 0x3ad0, + 0x396d, 0x3840, 0x39a5, 0x3965, 0x39a0, 0x38a2, 0x3405, 0x3b69, 0x3215, 0x3455, 0x3ba7, 0x38a9, + 0x3b13, 0x37d6, 0x352c, 0x39bb, 0x2998, 0x299f, 0x33fe, 0x3954, 0x3b3c, 0x3bff, 0x3b50, 0x35e9, + 0x2f7c, 0x2af3, 0x3bb8, 0x39ca, 0x3ad6, 0x38f6, 0x3a08, 0x34e1, 0x3966, 0x29cc, 0x3ac7, 0x33d2, + 0x39b2, 0x3631, 0x3b4f, 0x2879, 0x347c, 0x28cf, 0x3258, 0x38e1, 0x3ae6, 0x3801, 0x31c4, 0x331f, + 0x391f, 0x39b5, 0x2558, 0x368f, 0x3abe, 0x3a5d, 0x2180, 0x292d, 0x3612, 0x3b04, 0x35bd, 0x35a6, + 0x388e, 0x3a23, 0x392d, 0x2660, 0x3b09, 0x33d0, 0x2ff0, 0x3220, 0x3619, 0x3671, 0x394a, 0x363f, + 0x34a9, 0x2e8e, 0x3bfd, 0x3934, 0x3b61, 0x39c4, 0x38a2, 0x3a1b, 0x3a18, 0x3123, 0x2762, 0x3a95, + 0x350b, 0x3a9b, 0x3058, 0x3ade, 0x34e7, 0x372e, 0x3aec, 0x32b0, 0x3baa, 0x3444, 0x3aee, 0x2d22, + 0x33b7, 0x3223, 0x3980, 0x3a34, 0x365d, 0x3a11, 0x2d80, 0x39d0, 0x28d2, 0x3afb, 0x394b, 0x38e7, + 0x3646, 0x3a7f, 0x364a, 0x355f, 0x3861, 0x3836, 0x38ab, 0x30d1, 0x34df, 0x3998, 0x383c, 0x39e0, + 0x328f, 0x2d1e, 0x3757, 0x352a, 0x36d0, 0x3a49, 0x372a, 0x3953, 0x39d1, 0x3b88, 0x3695, 0x30e5, + 0x3ac7, 0x399c, 0x35f4, 0x3324, 0x3822, 0x3941, 0x3405, 0x3354, 0x38d1, 0x3b13, 0x22a8, 0x38e6, + 0x393b, 0x3bc4, 0x3b25, 0x2d11, 0x39a8, 0x3b80, 0x3894, 0x3541, 0x3a68, 0x338d, 0x3b57, 0x2794, + 0x352b, 0x39b7, 0x3a96, 0x380e, 0x3b86, 0x3826, 0x2ab0, 0x3a1d, 0x3abc, 0x3494, 0x3a05, 0x2e39, + 0x344e, 0x24a9, 0x3812, 0x354d, 0x3320, 0x3142, 0x35f7, 0x3aba, 0x2cd3, 0x3515, 0x3368, 0x1c0c, + 0x316e, 0x382e, 0x3aca, 0x374a, 0x3715, 0x395e, 0x37fe, 0x2e7d, 0x3701, 0x3841, 0x3957, 0x394c, + 0x3921, 0x2d98, 0x3265, 0x387d, 0x3b98, 0x3888, 0x396a, 0x3be0, 0x389f, 0x3932, 0x2eec, 0x2b3c, + 0x36e4, 0x3831, 0x389f, 0x3834, 0x378d, 0x38d7, 0x3451, 0x3961, 0x3083, 0x34e2, 0x32b0, 0x39e8, + 0x389a, 0x3770, 0x38ad, 0x3b42, 0x2f15, 0x37ac, 0x3ac8, 0x362f, 0x3be5, 0x3807, 0x343b, 0x3807, + 0x3017, 0x39c6, 0x37cd, 0x1b72, 0x3761, 0x39dd, 0x2bb9, 0x28d7, 0x3353, 0x3aeb, 0x33d6, 0x3816, + 0x34b6, 0x38dd, 0x3372, 0x37c4, 0x3953, 0x3b90, 0x38e6, 0x38d3, 0x374a, 0x2dd9, 0x390d, 0x3524, + 0x380f, 0x31eb, 0x37ba, 0x3414, 0x3050, 0x3a8d, 0x31f2, 0x3797, 0x399a, 0x3bf8, 0x3827, 0x343a, + 0x38b2, 0x32c4, 0x3693, 0x3ad0, 0x36c1, 0x331d, 0x37d9, 0x2870, 0x3666, 0x3941, 0x39bb, 0x2f03, + 0x33b2, 0x3a54, 0x3a09, 0x392f, 0x3bcc, 0x3604, 0x3bab, 0x39d3, 0x3a67, 0x3ac0, 0x3a36, 0x3b5e, + 0x3811, 0x3bb2, 0x3b32, 0x37f5, 0x3948, 0x3bae, 0x34e2, 0x35cc, 0x3b0d, 0x30b7, 0x30a0, 0x3ace, + 0x38e6, 0x3a9d, 0x393c, 0x3412, 0x30ae, 0x3244, 0x3620, 0x39c7, 0x3a3f, 0x3624, 0x3749, 0x3691, + 0x3921, 0x31a4, 0x2ee8, 0x3872, 0x3030, 0x3259, 0x34d0, 0x301b, 0x360c, 0x3979, 0x2845, 0x3a38, + 0x3851, 0x3a05, 0x3467, 0x381b, 0x3b1f, 0x3a2d, 0x30f8, 0x399a, 0x3805, 0x3110, 0x3bd6, 0x35b5, + 0x3091, 0x2fcd, 0x3049, 0x3bee, 0x385a, 0x3478, 0x31a9, 0x3be4, 0x3a1d, 0x2559, 0x39c5, 0x321e, + 0x33b9, 0x3b75, 0x37af, 0x39aa, 0x3948, 0x3726, 0x3aef, 0x301d, 0x36c2, 0x3a01, 0x2dfa, 0x311e, + 0x3b8d, 0x31f7, 0x30d5, 0x3a6b, 0x381c, 0x362b, 0x29c9, 0x34ac, 0x3993, 0x3828, 0x3b4d, 0x3aa3, + 0x3847, 0x34c8, 0x2b11, 0x3a5c, 0x2ebd, 0x2c9a, 0x395a, 0x366d, 0x398b, 0x255e, 0x3b7e, 0x2d74, + 0x356d, 0x33e3, 0x39ad, 0x2886, 0x39c7, 0x3996, 0x3bbd, 0x383c, 0x3b71, 0x3935, 0x3a02, 0x351a, + 0x3686, 0x31b1, 0x3a6c, 0x3afb, 0x3716, 0x3469, 0x351e, 0x3858, 0x377e, 0x2edb, 0x3baf, 0x30d7, + 0x3a60, 0x3906, 0x3baf, 0x3814, 0x32e6, 0x3bad, 0x34f9, 0x34ac, 0x37f6, 0x3ab7, 0x3035, 0x3701, + 0x35a6, 0x3aad, 0x3772, 0x3893, 0x3805, 0x1186, 0x3716, 0x387c, 0x3b15, 0x38da, 0xca2, 0x3a5f, + 0x2bcf, 0x2e9c, 0x3a15, 0x31d7, 0x331f, 0x3b99, 0x310a, 0x3538, 0x3b1b, 0x3616, 0x326f, 0x2f28, + 0x3bfc, 0x28a6, 0x3a09, 0x3489, 0x3769, 0x39c5, 0x3aa8, 0x3bce, 0x386c, 0x39ac, 0x39a0, 0x390b, + 0x3470, 0x388f, 0x3938, 0x3819, 0x354b, 0x3b99, 0x3978, 0x31fa, 0x357b, 0x3833, 0x38fa, 0x34ee, + 0x3bdb, 0x392c, 0x354e, 0x3b84, 0x3abe, 0x394b, 0x39ec, 0x3855, 0x39df, 0x39ad, 0x3ac8, 0x3871, + 0x2d02, 0x39a3, 0x3b0b, 0x3ab5, 0x34ca, 0x3afa, 0x3ade, 0x38df, 0x35f1, 0x3b1d, 0x28c5, 0x3b21, + 0x38db, 0x3450, 0x3b0b, 0x3b29, 0x38c1, 0x36e7, 0x3692, 0x31ee, 0x3b85, 0x3828, 0x38a7, 0x3972, + 0x2a44, 0x2ddd, 0x3ac7, 0x2de7, 0x3bba, 0x21c9, 0x3acb, 0x2e8c, 0x25f3, 0x3aa6, 0x3941, 0x32c5, + 0x3022, 0x397f, 0x3339, 0x2052, 0x2ecc, 0x37a5, 0x3ada, 0x3ac7, 0x326e, 0x38b1, 0x30f2, 0x322a, + 0x373e, 0x3a1b, 0x39a0, 0x3708, 0x38ab, 0x37f8, 0x30ac, 0x36e8, 0x3279, 0x354c, 0x38f9, 0x34ee, + 0x33b2, 0x3be9, 0x385c, 0x3b21, 0x3ba7, 0x39b1, 0x37da, 0x3036, 0x3a3f, 0x37c8, 0x3aed, 0x3578, + 0x3789, 0x31ac, 0x39d9, 0x3b22, 0x3b0d, 0x3a68, 0x35bb, 0x3a72, 0x386b, 0x3541, 0x309c, 0x3ab8, + 0x392c, 0x3bec, 0x390d, 0x364b, 0x3780, 0x34fa, 0x3537, 0x2117, 0x39ba, 0x3ae4, 0x37ce, 0x3ab4, + 0x3774, 0x29d7, 0x2e7d, 0x3853, 0x3bd0, 0x38a6, 0x39dc, 0x29ac, 0x37bd, 0x3986, 0x35f8, 0x3b9d, + 0x39b3, 0x363a, 0x399a, 0x3190, 0x3a04, 0x3b4f, 0x2c5f, 0x3081, 0x376c, 0x2f04, 0x2228, 0x3a8e, + 0x3900, 0x3936, 0x309f, 0x396b, 0x393e, 0x39b0, 0x35f6, 0x336b, 0x39b5, 0x3843, 0x3203, 0x2ffe, + 0x3be9, 0x3560, 0x3b30, 0x3740, 0x3739, 0x2a85, 0x333a, 0x37d6, 0x385a, 0x38eb, 0x32f6, 0x36b6, + 0x37b5, 0x37cf, 0x3a93, 0x35ac, 0x3bb9, 0x3bfb, 0x32b1, 0x3767, 0x3362, 0x3af0, 0x26b2, 0x38b5, + 0x39e7, 0x37b9, 0x2ccf, 0x38dd, 0x3424, 0x38b2, 0x3aa1, 0x393a, 0x3bf1, 0x37ea, 0x1aea, 0x3a53, + 0x3a73, 0x3a1f, 0x3934, 0x3be6, 0x366b, 0x369b, 0x267a, 0x35d2, 0x3aca, 0x38ad, 0x257d, 0x343e, + 0x3118, 0x3727, 0x3a70, 0x3838, 0x3462, 0x3142, 0x3a12, 0x3567, 0x3921, 0x362b, 0x3a1c, 0x383c, + 0x385f, 0x399c, 0x2d9f, 0x3b21, 0x2be6, 0x3905, 0x2bbe, 0x34fa, 0x3798, 0x3bd3, 0x3942, 0x3aef, + 0x39f7, 0x392b, 0x2bab, 0x2df9, 0x2cdc, 0x38ec, 0x35e3, 0x3270, 0x30c7, 0x380b, 0x2f85, 0x2ce0, + 0x3b0b, 0x38ee, 0x3a30, 0x3904, 0x3a66, 0x3ae5, 0x380e, 0x38fd, 0x3aed, 0x3b68, 0x3a1e, 0x39b2, + 0x38b0, 0x268a, 0x3964, 0x32b1, 0x32fc, 0x2c3b, 0x3568, 0x2a08, 0x2e62, 0x354a, 0x338f, 0x3b83, + 0x380b, 0x323d, 0x38d1, 0x34c3, 0x3484, 0x3bd6, 0x30f6, 0x36e0, 0x396a, 0x35fa, 0x39c0, 0x3624, + 0x3a16, 0x3918, 0x2f14, 0x31ed, 0x3bb8, 0x38a6, 0x3af8, 0x35f0, 0x3985, 0x3454, 0x3b4d, 0x39c0, + 0x3821, 0x36e2, 0x2549, 0x36aa, 0x3816, 0x3a0a, 0x3750, 0x3b7a, 0x3898, 0x3ac6, 0x363e, 0x330d, + 0x34b4, 0x3a2d, 0x3502, 0x355b, 0x3ba5, 0x3a84, 0x38d4, 0x37c3, 0x31bc, 0x391e, 0x3512, 0x36a9, + 0x3241, 0x3ada, 0x3108, 0x349b, 0x3027, 0x3750, 0x3839, 0x3abf, 0x396f, 0x35af, 0x3680, 0x38f6, + 0x38d4, 0x3351, 0x3056, 0x3260, 0x2f02, 0x38f9, 0x35f0, 0x32ab, 0x3923, 0x3898, 0x3af0, 0x303f, + 0x3934, 0x3a58, 0x3ab1, 0x3abd, 0x31c1, 0x34ac, 0x3921, 0x3075, 0x269b, 0x2961, 0x3569, 0x37d3, + 0x35a2, 0x3b52, 0x39e5, 0x3817, 0x3866, 0x3744, 0x3665, 0x3be9, 0x33c6, 0x3010, 0x2d3f, 0x39f3, + 0x2ed1, 0x35d9, 0x2d6f, 0x35be, 0x39ad, 0x2b83, 0x3adf, 0x3a32, 0x3bcd, 0x3456, 0x375f, 0x37a3, + 0x3098, 0x3bbe, 0x36b7, 0x2df1, 0x3931, 0x3142, 0x30d3, 0x2a49, 0x2d72, 0x262d, 0x39bc, 0x3bfa, + 0x3abc, 0x3ac0, 0x3531, 0x3800, 0x36d4, 0x379c, 0x3aba, 0x3053, 0x350e, 0x3989, 0x3003, 0x3a51, + 0x37cc, 0x34fd, 0x333a, 0x33f1, 0x3a0a, 0x345d, 0x38e0, 0x28e4, 0x3a64, 0x317f, 0x2cad, 0x395a, + 0x343c, 0x3ba7, 0x39ea, 0x3b5b, 0x34ff, 0x3955, 0x39d1, 0x360a, 0x2f25, 0x3a4d, 0x3889, 0x2eb6, + 0x3021, 0x396d, 0x379f, 0x3495, 0x38d5, 0x3963, 0x33ae, 0x3bfd, 0x211f, 0x3aed, 0x2fd8, 0x3b2d, + 0x33eb, 0x2c29, 0x3954, 0x3219, 0x3958, 0x3b2f, 0x3578, 0x315d, 0x387a, 0x2561, 0x3ba4, 0x39cb, + 0x341e, 0x375f, 0x39ad, 0x3700, 0x3ab9, 0x34c1, 0x3051, 0x3b77, 0x3705, 0x3ae6, 0x3b58, 0x37d5, + 0x3a6c, 0x3476, 0x3589, 0x2818, 0x35c5, 0x3876, 0x3871, 0x35a8, 0x30c9, 0x357e, 0x38c9, 0x38a1, + 0x35cf, 0x36db, 0x3401, 0x34a6, 0x3826, 0x37fe, 0x3beb, 0x38ed, 0x322c, 0x352a, 0x38e1, 0x3bf1, + 0x32fa, 0x3bd5, 0x3310, 0x361e, 0x3af0, 0x323b, 0x3565, 0x23c8, 0x3b28, 0x3853, 0x2aab, 0x39d9, + 0x3bbf, 0x3b2d, 0x35ce, 0x3a4a, 0x3992, 0x35ac, 0x1723, 0x38fa, 0x38d7, 0x354c, 0x3b0b, 0x3888, + 0x3a98, 0x38f6, 0x391d, 0x381b, 0x38cf, 0x3a60, 0x2a34, 0x3a09, 0x2257, 0x3a63, 0x3ab7, 0x3494, + 0x2955, 0x3978, 0x3ba2, 0x2804, 0x384e, 0x383d, 0x3be4, 0x391e, 0x3851, 0x3908, 0x2084, 0x35a8, + 0x2f69, 0x3adc, 0x3a16, 0x3990, 0x3479, 0x3551, 0x389b, 0x3bd6, 0x3128, 0x3835, 0x3541, 0x306f, + 0x380e, 0x341d, 0x3a6e, 0x3a12, 0x3a77, 0x3464, 0x3aa9, 0x3693, 0x34ae, 0x35c2, 0x3346, 0x3ad0, + 0x3857, 0x2ad5, 0x3ba7, 0x3327, 0x3ae6, 0x32df, 0x3be9, 0x3544, 0x3060, 0x39c0, 0x2daa, 0x376d, + 0x3a90, 0x3b29, 0x380e, 0x33a6, 0x347f, 0x3b7c, 0x3b9d, 0x31e3, 0x393e, 0x3a56, 0x3bcb, 0x38f9, + 0x3656, 0x3011, 0x3be5, 0x32c5, 0x3807, 0x39a7, 0x35e6, 0x3a3a, 0x33cf, 0x37c8, 0x3af2, 0x3a42, + 0x3119, 0x3534, 0x3b1d, 0x29dd, 0x3ab6, 0x38c3, 0x35d0, 0x3189, 0x3635, 0x38d2, 0x2fb9, 0x3944, + 0x3918, 0x333e, 0x3ab8, 0x31ba, 0x3a3f, 0x3b87, 0x3508, 0x2f76, 0x3670, 0x3043, 0x3aa9, 0x360d, + 0x3807, 0x3a78, 0x3909, 0x39a1, 0x32f5, 0x3667, 0x3125, 0x386c, 0x3702, 0x3a83, 0x397e, 0x2d4a, + 0x399a, 0x3b13, 0x351e, 0x39e5, 0x39bb, 0x374f, 0x2c0a, 0x3ade, 0x31d8, 0x3b82, 0x3a5d, 0x3598, + 0x391f, 0x3a76, 0x3641, 0x2fe2, 0x38bd, 0x3abb, 0x3988, 0x36b2, 0x3b1e, 0x37d5, 0x3509, 0x38e0, + 0x2e2c, 0x34fd, 0x3053, 0x32da, 0x3988, 0x3a32, 0x3a4c, 0x356d, 0x3716, 0x3449, 0x2bd1, 0x34d8, + 0x3600, 0x385a, 0x39cf, 0x3850, 0x2d4c, 0x3ba5, 0x39ba, 0x393a, 0x3be8, 0x3823, 0x37b0, 0x3b15, + 0x3bbe, 0x3869, 0x301a, 0x337b, 0x3be3, 0x2e58, 0x39fb, 0x31fb, 0x385e, 0x3863, 0x36ca, 0x31e9, + 0x32da, 0x377b, 0x375b, 0x3ac7, 0x3b05, 0x36f6, 0x3aa6, 0x3182, 0x38f8, 0x396c, 0x34d8, 0x383c, + 0x3602, 0x3744, 0x3b2b, 0x381e, 0x320b, 0x3674, 0x39b1, 0x32ea, 0x37a9, 0x3800, 0x3a3a, 0x3876, + 0x32a5, 0x3b99, 0x305d, 0x26ce, 0x38ae, 0x3a69, 0x362a, 0x2cb4, 0x31da, 0x3bb7, 0x2e60, 0x3539, + 0x397c, 0x398f, 0x3972, 0x33a9, 0x38d9, 0x3733, 0x3991, 0x367d, 0x3af9, 0x380f, 0x3b6d, 0x2c45, + 0x35cb, 0x31ab, 0x3349, 0x2f9b, 0x3a48, 0x3a3b, 0x3b5e, 0x2ee0, 0x3061, 0x3010, 0x39a0, 0x3861, + 0x38d2, 0x3b18, 0x328f, 0x39ac, 0x370f, 0x3485, 0x3acf, 0x39d7, 0x3703, 0x39dc, 0x2995, 0x2ff2, + 0x29f2, 0x3914, 0x3796, 0x37a8, 0x36e7, 0x3964, 0x3797, 0x3801, 0x387a, 0x3942, 0x383e, 0x3603, + 0x337f, 0x30f3, 0x34b5, 0x39e4, 0x39dd, 0x3432, 0x36db, 0x38ae, 0x3533, 0x39c0, 0x38f5, 0x3af3, + 0x304f, 0x3ba0, 0x3a69, 0x39a1, 0x35bd, 0x3414, 0x3917, 0x36c4, 0x3a75, 0x3a43, 0x38c3, 0x383e, + 0x2e3b, 0x2629, 0x2de1, 0x399b, 0x3153, 0x3525, 0x32a6, 0x3559, 0x3a09, 0x39cf, 0x368f, 0x316b, + 0x399a, 0x3aff, 0x3141, 0x2682, 0x2f25, 0x3922, 0x34fc, 0x361a, 0x311e, 0x39ea, 0x2d24, 0x398e, + 0x3968, 0x3bb0, 0x3b97, 0x2894, 0x32e8, 0x2fda, 0x32a1, 0x3a45, 0x39c5, 0x38ce, 0x3bb2, 0x3945, + 0x3911, 0x2c10, 0x3bbd, 0x3bb2, 0x3675, 0x3395, 0x38ab, 0x2c1e, 0x35be, 0x35c7, 0x37b8, 0x25fc, + 0x3b68, 0x307f, 0x3429, 0x3b54, 0x3395, 0x3bdf, 0x373d, 0x3780, 0x323b, 0x3a5c, 0x394d, 0x39c2, + 0x3b10, 0x3811, 0x3785, 0x3ab3, 0x3bf2, 0x38fc, 0x37cd, 0x3603, 0x3633, 0x3ac0, 0x1816, 0x33b4, + 0x3244, 0x31e0, 0x3ac1, 0x39c7, 0x393f, 0x38f7, 0x32a8, 0x39dd, 0x39f6, 0x3a08, 0x3683, 0x3946, + 0x3b26, 0x2dbd, 0x3849, 0x3623, 0x3722, 0x396d, 0x3885, 0x38b4, 0x3965, 0x3352, 0x39b5, 0x3896, + 0x2fde, 0x30f3, 0x392d, 0x3105, 0x3a16, 0x3967, 0x375f, 0x3866, 0x2c5a, 0x3987, 0x2f60, 0x39f0, + 0x33ef, 0x38e9, 0x390d, 0x3a72, 0x373e, 0x3825, 0x3711, 0x2baa, 0x3a4f, 0x3856, 0x3404, 0x3656, + 0x2eca, 0x2b84, 0x3607, 0x3a23, 0x3ab3, 0x3758, 0x2eba, 0x3bd7, 0x3a17, 0x3b20, 0x34d5, 0x39cd, + 0x34e9, 0x2e07, 0x3866, 0x34f0, 0x2fde, 0x31c1, 0x376e, 0x3a9f, 0x35dd, 0x34cf, 0x366d, 0x3a74, + 0x39a9, 0x3910, 0x323f, 0x2c98, 0x363f, 0x2805, 0x31b2, 0x39d2, 0x3ba0, 0x3494, 0x3bd7, 0x3a5c, + 0x3465, 0x30de, 0x287c, 0x36cc, 0x378f, 0x2b94, 0x3bcd, 0x349d, 0x38fb, 0x37ba, 0x3bb3, 0x388e, + 0x2834, 0x33b4, 0x3b67, 0x38d7, 0x3910, 0x3a92, 0x329b, 0x2e40, 0x36ba, 0x3813, 0x32c6, 0x3460, + 0x3737, 0x3a3c, 0x2aa0, 0x3124, 0x3582, 0x3962, 0x39d7, 0x31bc, 0x38ac, 0x3281, 0x3103, 0x36ed, + 0x3a20, 0x39a8, 0x38dd, 0x3917, 0x3b18, 0x3311, 0x2ca3, 0x39f3, 0x3bc4, 0x319b, 0x2b75, 0x3571, + 0x34f0, 0x348d, 0x27a2, 0x38a8, 0x347e, 0x3b66, 0x2ffb, 0x35fe, 0x34d1, 0x3ad6, 0x2d9d, 0x3a66, + 0x3226, 0x3a3f, 0x378c, 0x3be5, 0x3342, 0x3aa0, 0x3ad5, 0x3773, 0x2ec6, 0x3888, 0x35ad, 0x3b7f, + 0x3b4f, 0x354e, 0x384d, 0x34b5, 0x37f4, 0x32a3, 0x3976, 0x2085, 0x3b1b, 0x291e, 0x3537, 0x2ccc, + 0x2e4c, 0x3a5a, 0x3572, 0x3860, 0x2d4e, 0x37c4, 0x270c, 0x3ab4, 0x384d, 0x3740, 0x3a53, 0x3a5a, + 0x39c2, 0x3abe, 0x393b, 0x3612, 0x3879, 0x3793, 0x3096, 0x388e, 0x3930, 0x3729, 0x353c, 0x39aa, + 0x38e4, 0x383a, 0x3028, 0x3578, 0x2e4e, 0x2e63, 0x38a0, 0x3b2b, 0x3b90, 0x3a0f, 0x2d9c, 0x35bc, + 0x3b96, 0x35d0, 0x3bf2, 0x3bde, 0x28f8, 0x3943, 0x39aa, 0x39c2, 0x38f4, 0x3571, 0x157d, 0x3b17, + 0x304c, 0x363d, 0x2c68, 0x3ba0, 0x3b0e, 0x3513, 0x3669, 0x300c, 0x3852, 0x39f2, 0x3474, 0x3a66, + 0x2c9f, 0x2dc2, 0x3b0a, 0x39d1, 0x3942, 0x2422, 0x3ad6, 0x34ec, 0x3b73, 0x3abd, 0x2e73, 0x3581, + 0x34b0, 0x25a8, 0x37b9, 0x3924, 0x2f7b, 0x3a6d, 0x3b6b, 0x3378, 0x3bb2, 0x3ace, 0x38a2, 0x349a, + 0x3b68, 0x3647, 0x3847, 0x3bd1, 0x3be4, 0x39be, 0x3ac5, 0x397f, 0x22c0, 0x3692, 0x3ba8, 0x384c, + 0x3bcb, 0x36d9, 0x3783, 0x3bf4, 0x3852, 0x3b7b, 0x325d, 0x37db, 0x35ed, 0x36f2, 0x371b, 0x3605, + 0x3645, 0x228f, 0x358a, 0x34f0, 0x38d9, 0x35ee, 0x3620, 0x3b4a, 0x3a86, 0x3927, 0x3799, 0x3297, + 0x3474, 0x34c1, 0x3af8, 0x2dec, 0x2dc6, 0x36f3, 0x30bb, 0x31c4, 0x36d7, 0x37cc, 0x349d, 0x27d7, + 0x3a7f, 0x3481, 0x3791, 0x3b71, 0x371b, 0x3838, 0x34c9, 0x2668, 0x310e, 0x3333, 0x39ee, 0x37b4, + 0x2bc6, 0x1a59, 0x3afd, 0x39dc, 0x38b1, 0x394a, 0x3697, 0x3103, 0x366c, 0x397a, 0x31b0, 0x32db, + 0x3050, 0x3899, 0x36d5, 0x3bfd, 0x3a67, 0x38b6, 0x39c1, 0x322b, 0x2d8a, 0x38f3, 0x397a, 0x3b71, + 0x28af, 0x3a4e, 0x3b7d, 0x388d, 0x3aeb, 0x3bf1, 0x3bc9, 0x242f, 0x3681, 0x2f1f, 0x3bd6, 0x391e, + 0x31d1, 0x3be6, 0x39fe, 0x3acb, 0x3871, 0x38ae, 0x30ca, 0x3916, 0x36ce, 0x3313, 0x3a4d, 0x3869, + 0x35b6, 0x3a6d, 0x376d, 0x3922, 0x27d8, 0x39a6, 0x3a3c, 0x2e99, 0x2fdd, 0x3b05, 0x3b6a, 0x3520, + 0x3714, 0x3922, 0x38c4, 0x3b47, 0x3546, 0x2ba3, 0x37c2, 0x381d, 0x3af2, 0x3b8c, 0x289e, 0x3a3a, + 0x3ae3, 0x3829, 0x399f, 0x351f, 0x3bff, 0x37da, 0x3b94, 0x3874, 0x3bf8, 0x3943, 0x324d, 0x34bb, + 0x3925, 0x38c0, 0x2e81, 0x32d8, 0x3bea, 0x3bcc, 0x387b, 0x3537, 0x3344, 0x3bef, 0x3345, 0x3a47, + 0x330c, 0x367c, 0x3792, 0x36f5, 0x384b, 0x3b2e, 0x3998, 0x38dd, 0x25c0, 0x3a12, 0x390d, 0x2ffd, + 0x372f, 0x30ea, 0x2ee4, 0x3a81, 0x3ba2, 0x377c, 0x3446, 0x3a57, 0x38cb, 0x3994, 0x360e, 0x3b8c, + 0x2f0c, 0x139c, 0x2cce, 0x37af, 0x253d, 0x3287, 0x3b58, 0x3177, 0x3b3e, 0x3426, 0x32b0, 0x3349, + 0x3b02, 0x38f3, 0x3a06, 0x3b05, 0x3490, 0x3bcb, 0x3ba6, 0x248a, 0x32e8, 0x3be2, 0x2d59, 0x3909, + 0x365f, 0x395a, 0x3025, 0x3862, 0x28c9, 0x3bdf, 0x3360, 0x3bfe, 0x2a94, 0x394b, 0x337f, 0x2d8e, + 0x3ad1, 0x38e1, 0x3bf1, 0x38b5, 0x3681, 0x3984, 0x347a, 0x2bbf, 0x38dc, 0x393d, 0x3552, 0x315e, + 0x3309, 0x36b5, 0x39d3, 0x361f, 0x387f, 0x3828, 0x344e, 0x3a55, 0x36d3, 0x187a, 0x22ef, 0x3032, + 0x373f, 0x360d, 0x396c, 0x37bf, 0x3472, 0x3220, 0x3bd3, 0x2c5b, 0x384b, 0x328e, 0x396e, 0x369c, + 0x3798, 0x2e60, 0x3a58, 0x3a47, 0x3a0c, 0x3bb1, 0x32c2, 0x3a49, 0x3523, 0x37aa, 0x2e18, 0x376d, + 0x37d8, 0x344e, 0x2328, 0x31d9, 0x3493, 0x32a2, 0x2f0a, 0x3b5a, 0x2fec, 0x30dc, 0x3ad0, 0x3b82, + 0x37b9, 0x3695, 0x3892, 0x390a, 0x3a1f, 0x35c7, 0x39c5, 0x31f9, 0x3994, 0x3165, 0x357d, 0x3a36, + 0x2fcd, 0x39c4, 0x398f, 0x3950, 0x36d1, 0x39d0, 0x37c1, 0x3bd4, 0x3ad8, 0x396c, 0x3899, 0x3ba0, + 0x356d, 0x3232, 0x3001, 0x396a, 0x28e8, 0x3a21, 0x1670, 0x3bcd, 0x3814, 0x3bf2, 0x3b85, 0x38e7, + 0x35ae, 0x2d51, 0x3751, 0x33ec, 0x37b2, 0x392e, 0x3a51, 0x3654, 0x3b55, 0x2ec9, 0x38dc, 0x3a39, + 0x3425, 0x2c2a, 0x3bfa, 0x3bc1, 0x3489, 0x3027, 0x3a32, 0x2fdf, 0x3a72, 0x38c7, 0x3580, 0x3769, + 0x3be7, 0x32fb, 0x32b0, 0x3b73, 0x3b3c, 0x38f6, 0x38f5, 0x25a2, 0x3856, 0x3a23, 0x2d10, 0x356f, + 0x38d6, 0x3ae4, 0x328c, 0x3913, 0x3a39, 0x3745, 0x352a, 0x33d2, 0x3ac2, 0x3874, 0x3b1e, 0x2f5b, + 0x3a62, 0x37f1, 0x38c3, 0x3bcc, 0x3334, 0x38b5, 0x3400, 0x3571, 0x38df, 0x3a54, 0x3380, 0x302c, + 0x3448, 0x3bb5, 0x3bf5, 0x31b6, 0x3aca, 0x3b8d, 0x3b8e, 0x3a8e, 0x3390, 0x3b14, 0x2e8e, 0x3855, + 0x3956, 0x34fd, 0x2cfa, 0x32cf, 0x3a1c, 0x3632, 0x373a, 0x38d4, 0x3869, 0x3b46, 0x3445, 0x381d, + 0x339b, 0x3a0a, 0x347e, 0x3b30, 0x38ed, 0x3138, 0x2bbd, 0x3a6d, 0x3b82, 0x383a, 0x2592, 0x39b7, + 0x23ea, 0x3962, 0x3a77, 0x3b68, 0x3877, 0x312b, 0x387a, 0x3167, 0x3149, 0x383e, 0x3806, 0x3b3b, + 0x31db, 0x38ce, 0x34e8, 0x2856, 0x3666, 0x3a6e, 0x36ee, 0x32b9, 0x3569, 0x3b2e, 0x3b41, 0x390d, + 0x356e, 0x39fb, 0x3b59, 0x2e2e, 0x36b2, 0x3a09, 0x2e8d, 0x3616, 0x3906, 0x360a, 0x3a22, 0x2ace, + 0x3bd9, 0x309a, 0x33c5, 0x2c68, 0x315d, 0x3beb, 0x39a6, 0x36d2, 0x36d0, 0x300e, 0x3950, 0x35f2, + 0x3ac7, 0x2ee6, 0x30ac, 0x38e3, 0x33a2, 0x30f1, 0x2cb9, 0x30c2, 0x350e, 0x3781, 0x39f2, 0x39f4, + 0x3081, 0x357f, 0x354a, 0x3496, 0x39ad, 0x37d6, 0x38d9, 0x3477, 0x26fd, 0x341c, 0x34a6, 0x2e76, + 0x3a8c, 0x37ff, 0x31b3, 0x3bce, 0x3855, 0x39e7, 0x32e1, 0x382f, 0x2e07, 0x37cc, 0x397a, 0x3985, + 0x367a, 0x3b66, 0x3bc8, 0x2fea, 0x32c7, 0x3a73, 0x34b8, 0x3a30, 0x3830, 0x3904, 0x3855, 0x2bde, + 0x3598, 0x29f7, 0x3a60, 0x39b9, 0x33c1, 0x3b82, 0x38fb, 0x37ce, 0x2cc0, 0x3117, 0x3928, 0x3243, + 0x2c2a, 0x38bc, 0x35b4, 0x3946, 0x38b8, 0x3403, 0x3862, 0x3a80, 0x36c2, 0x3ad4, 0x38c5, 0x3631, + 0x3a1a, 0x387a, 0x3308, 0x3099, 0x3834, 0x35af, 0x2eb7, 0x3473, 0x31a8, 0x3795, 0x3a31, 0x3be6, + 0x3858, 0x27e9, 0x36ba, 0x3109, 0x3916, 0x372d, 0x357c, 0x32ac, 0x37d7, 0x3654, 0x37c1, 0x383f, + 0x3368, 0x350d, 0x3b3e, 0x3af4, 0x35a9, 0x3514, 0x3a3c, 0x36a3, 0x3bb3, 0x3ba2, 0x33b3, 0x398e, + 0x3593, 0x32b4, 0x3bef, 0x34d9, 0x3bad, 0x39a9, 0x15e1, 0x3b2c, 0x3b74, 0x3824, 0x3893, 0x35bd, + 0x3b68, 0x32ca, 0x3ace, 0x3a27, 0x341f, 0x3a95, 0x3397, 0x3585, 0x2a43, 0x348f, 0x3b93, 0x3a55, + 0x38d0, 0x39d9, 0x342a, 0x3252, 0x30e5, 0x24f6, 0x34ef, 0x38f4, 0x35af, 0x2fbf, 0x2f85, 0x2cf8, + 0x29a9, 0x360d, 0x3a3d, 0x319a, 0x2cf9, 0x3acf, 0x38c5, 0x3761, 0x35d5, 0x2e99, 0x328d, 0x38fb, + 0x3aef, 0x39cd, 0x2f04, 0x3516, 0x395d, 0x34bd, 0x326c, 0x399e, 0x2a6f, 0x3a69, 0x3343, 0x3a7f, + 0x34c3, 0x39de, 0x3b7b, 0x3968, 0x3900, 0x35e6, 0x3a88, 0x3498, 0x370d, 0x2cb7, 0x3825, 0x3b08, + 0x3b62, 0x383d, 0x34f7, 0x35e5, 0x2dac, 0x37c3, 0x3041, 0x2e34, 0x2d89, 0x315c, 0x3b17, 0x366b, + 0x393f, 0x3a05, 0x2577, 0x3468, 0x3aee, 0x39d2, 0x3adb, 0x38e7, 0x2695, 0x39df, 0x30b8, 0x3667, + 0x34fc, 0x3157, 0x371c, 0x34b0, 0x38a7, 0x374c, 0x3413, 0x37b4, 0x391b, 0x2ee9, 0x3899, 0x3adc, + 0x308b, 0x2cff, 0x35b9, 0x37ff, 0x3967, 0x36bd, 0x3185, 0x3be4, 0x394b, 0x33eb, 0x3879, 0x3ad9, + 0x31a5, 0x38c0, 0x343e, 0x362e, 0x3b6e, 0x2bad, 0x39fa, 0x3a43, 0x3933, 0x3b78, 0x35d5, 0x3625, + 0x371a, 0x3a9f, 0x3b94, 0x3665, 0x3915, 0x3895, 0x3522, 0x3897, 0x38c0, 0x3738, 0x3115, 0x36b4, + 0x3778, 0x38c1, 0x2e5c, 0x244f, 0x3808, 0x372c, 0x3107, 0x3448, 0x3ace, 0x380a, 0x3a17, 0x394a, + 0x3afd, 0x3a06, 0x2ccb, 0x38d7, 0x320b, 0x327b, 0x308a, 0x3586, 0x2f07, 0x36c8, 0x3a49, 0x39fe, + 0x261b, 0x2fd9, 0x2d24, 0x373f, 0x2edf, 0x385b, 0x3b8a, 0x31fa, 0x39c1, 0x3b43, 0x3b07, 0x374a, + 0x3ba5, 0x2190, 0x343c, 0x2cac, 0x3634, 0x36a7, 0x3aff, 0x3767, 0x3b8d, 0x3919, 0x315c, 0x3acd, + 0x33a4, 0x39af, 0x3b60, 0x3a54, 0x3967, 0x3bfe, 0x34ba, 0x3681, 0x3597, 0x30bf, 0x31db, 0x3709, + 0x3550, 0x3a37, 0x34c2, 0x381b, 0x3b4e, 0x2dd2, 0x3bc4, 0x3b1d, 0x393b, 0x3b43, 0x1c81, 0x35e7, + 0x3922, 0x38d8, 0x371e, 0x39ea, 0x3995, 0x2ce3, 0x26d7, 0x3547, 0x3803, 0x350a, 0x3142, 0x3a85, + 0x3482, 0x3896, 0x38ac, 0x348f, 0x34be, 0x1a12, 0x36be, 0x3973, 0x3a40, 0x3543, 0x20e1, 0x34e7, + 0x3567, 0x33db, 0x3108, 0x39a1, 0x3718, 0x36e0, 0x2df2, 0x3953, 0x3434, 0x22a8, 0x3957, 0x26f0, + 0x324e, 0x31fc, 0x3673, 0x3355, 0x3979, 0x3a9a, 0x3914, 0x383a, 0x3726, 0x3bfd, 0x37ad, 0x38f1, + 0x333a, 0x2dca, 0x35ff, 0x3af8, 0x3aef, 0x3b69, 0x371c, 0x373d, 0x2eb4, 0x36c4, 0x38fc, 0x3852, + 0x31b3, 0x3b4b, 0x279c, 0x36d4, 0x397a, 0x3430, 0x347b, 0x3a11, 0x330f, 0x353d, 0x3a3e, 0x395e, + 0x3b26, 0x3912, 0x301b, 0x314c, 0x3480, 0x3a2b, 0x2f76, 0x3b15, 0x3914, 0x2df3, 0x38f0, 0x3698, + 0x3bcc, 0x3b94, 0x3be8, 0x3478, 0x311f, 0x366b, 0x2693, 0x3a55, 0x2855, 0x3982, 0x3a0c, 0x3b4e, + 0x3626, 0x387e, 0x3bac, 0x3ba4, 0x3bcc, 0x3ae6, 0x3a77, 0x3435, 0x2f57, 0x34a8, 0x3410, 0x3531, + 0x34a3, 0x3a71, 0x380a, 0x3bb2, 0x1f10, 0x3aa0, 0x3b1c, 0x3984, 0x3937, 0x3bd7, 0x36b1, 0x31c2, + 0x338d, 0x26f9, 0x3923, 0x38e8, 0x1b4b, 0x397a, 0x35fd, 0x28e7, 0x36c0, 0x3a1a, 0x394d, 0x38ba, + 0x39ef, 0x3795, 0x303a, 0x3110, 0x3a36, 0x30cd, 0x2d48, 0x3a2e, 0x32a9, 0x374a, 0x381d, 0x36dc, + 0x39c1, 0x2d15, 0x3ae9, 0x1df9, 0x3bb6, 0x3aec, 0x2b5a, 0x39ed, 0x33ff, 0x3630, 0x3872, 0x35d8, + 0x358a, 0x2ca9, 0x3773, 0x38bc, 0x3656, 0x2ffb, 0x3be8, 0x278d, 0x3b4e, 0x39a7, 0x3375, 0x29bc, + 0x3946, 0x34ba, 0x2cf9, 0x3629, 0x3aff, 0x33f5, 0x26f2, 0x3a59, 0x2cfc, 0x3210, 0x38ee, 0x361d, + 0x3060, 0x374e, 0x344b, 0x3975, 0x31eb, 0x3560, 0x37e6, 0x2a97, 0x36a6, 0x3b65, 0x34a3, 0x35bb, + 0x35af, 0x36b6, 0x3757, 0x38fb, 0x396f, 0x3ad4, 0x3962, 0x2b38, 0x39e5, 0x3159, 0x39be, 0x3202, + 0x2387, 0x387a, 0x3463, 0x37c4, 0x39ce, 0x34a3, 0x37bd, 0x3ac0, 0x359a, 0x31db, 0x327c, 0x391e, + 0x3a9f, 0x36cc, 0x3961, 0x2264, 0x3583, 0x396f, 0x3a9f, 0x2ad9, 0x36ec, 0x32b3, 0x2fd5, 0x397a, + 0x352d, 0x343d, 0x3841, 0x3964, 0x39c4, 0x3a81, 0x3acb, 0x34f0, 0x38b4, 0x375a, 0x3a25, 0x3932, + 0x393f, 0x3025, 0x397c, 0x3a55, 0x37c6, 0x32f4, 0x3bae, 0x3a48, 0x31cf, 0x38b5, 0x366c, 0x3451, + 0x23c6, 0x36a2, 0x38eb, 0x3bde, 0x3318, 0x3667, 0x3b5a, 0x3867, 0x30e6, 0x3256, 0x3499, 0x38b5, + 0x2e31, 0x3408, 0x3a30, 0x345a, 0x3a32, 0x3b26, 0x34cd, 0x39c8, 0x34b0, 0x39f6, 0x2cc9, 0x3906, + 0x3121, 0x39e8, 0x3b18, 0x3973, 0x31ac, 0x3803, 0x33a5, 0x3034, 0x3940, 0x310e, 0x3a82, 0x21dc, + 0x3b7b, 0x388d, 0x3166, 0x3967, 0x35f3, 0x3942, 0x3a4c, 0x380f, 0x3852, 0x37d2, 0x37ad, 0x388c, + 0x39b9, 0x34b2, 0x2ca4, 0x382d, 0x3ad5, 0x3662, 0x397d, 0x30b3, 0x2c1c, 0x3447, 0x33a7, 0x30ef, + 0x39a6, 0x3bcf, 0x3ac9, 0x3083, 0x387a, 0x3ae9, 0x3acd, 0x38b8, 0x3a8d, 0x32cb, 0x32f3, 0x2f98, + 0x3a4d, 0x2846, 0x3bba, 0x3ab7, 0x31c6, 0x2b8e, 0x3188, 0x3b27, 0x3b0a, 0x3abf, 0x3b9e, 0x2d16, + 0x34fc, 0x34d9, 0x38f3, 0x389d, 0x3520, 0x323c, 0x3b1b, 0x38d6, 0x3a6c, 0x38d7, 0x352d, 0x3ab7, + 0x388d, 0x3b66, 0x35c3, 0x3a06, 0x3ad3, 0x3bd2, 0x395c, 0x3aa0, 0x3903, 0x3bcc, 0x2ff8, 0x3bba, + 0x3511, 0x3bf8, 0x352c, 0x3a37, 0x367a, 0x3710, 0x3a4d, 0x30d2, 0x347a, 0x384b, 0x39d2, 0x3455, + 0x2eeb, 0x3a46, 0x3a88, 0x3a1c, 0x3a18, 0x3b52, 0x3136, 0x3853, 0x37ac, 0x39dd, 0x372d, 0x352b, + 0x3598, 0x344c, 0x3886, 0x3910, 0x3350, 0x3a31, 0x351f, 0x397c, 0x3bb6, 0x3121, 0x397f, 0x36b4, + 0x3bd3, 0x3a3f, 0x3b1d, 0x3a22, 0x39df, 0x3bc6, 0x31b6, 0x3a7c, 0x389a, 0x3927, 0x36a9, 0x3694, + 0x385a, 0x3611, 0x31cd, 0x309b, 0x3af7, 0x352f, 0x3a81, 0x3894, 0x29ee, 0x3b55, 0x39c6, 0x388a, + 0x307e, 0x39d9, 0x2753, 0x3451, 0x34a2, 0x3a16, 0x3672, 0x3466, 0x3078, 0x21c5, 0x307d, 0x3803, + 0x35d5, 0x3bed, 0x2e8f, 0x3426, 0x3427, 0x3a78, 0x30e9, 0x39b3, 0x37da, 0x3818, 0x380b, 0x38c9, + 0x3ba5, 0x320b, 0x3935, 0x36e4, 0x38ef, 0x3b81, 0x2f22, 0x39ba, 0x3755, 0x3b1c, 0x39cd, 0x386f, + 0x2d6e, 0x335b, 0x3aba, 0x3b3f, 0x3b6c, 0x3293, 0x3177, 0x3bd5, 0x309f, 0x343a, 0x2dee, 0x3240, + 0x353e, 0x356a, 0x30ed, 0x3b56, 0x3977, 0x343e, 0x32c7, 0x3a75, 0x315b, 0x3015, 0x32fd, 0x363d, + 0x3a68, 0x386e, 0x2dc3, 0x34f3, 0x3bfb, 0x398f, 0x37db, 0x3bbc, 0x3015, 0x38a5, 0x21e7, 0x3863, + 0x2fca, 0x3152, 0x3acb, 0x390b, 0x3bc2, 0x3a5e, 0x3823, 0x3b36, 0x2c67, 0x3b1c, 0x34cc, 0x1c43, + 0x3431, 0x3088, 0x3707, 0x36a9, 0x3bdf, 0x2a64, 0x3891, 0x327a, 0x393c, 0x2971, 0x3304, 0x39b0, + 0x3a92, 0x2df5, 0x398e, 0x2ea4, 0x34be, 0x3449, 0x3037, 0x382c, 0x380e, 0x3a44, 0x35d1, 0x3539, + 0x39f4, 0x3b7f, 0x2974, 0x3a97, 0x3bdb, 0x3a60, 0x34cf, 0x3641, 0x2e66, 0x1e72, 0x398d, 0x3568, + 0x39eb, 0x3b8d, 0x343d, 0x3af4, 0x39bc, 0x35ef, 0x23e5, 0x3826, 0x3841, 0x36fc, 0x342b, 0x30a4, + 0x2f48, 0x1165, 0x2842, 0x3059, 0x3811, 0x32fb, 0x3aec, 0x3a8b, 0x2e51, 0x3aeb, 0x385e, 0x2a73, + 0x28b8, 0x36df, 0x3453, 0x37f1, 0x2dfb, 0x2bed, 0x3b52, 0x39a6, 0x395a, 0x37b9, 0x3492, 0x3490, + 0x34a9, 0x37de, 0x394e, 0x3934, 0x37f4, 0x3909, 0x1ef5, 0x344f, 0x3852, 0x3b64, 0x3a06, 0x2e82, + 0x2cd9, 0x31a7, 0x382b, 0x34b7, 0x3a2b, 0x372d, 0x36ba, 0x2932, 0x3b1e, 0x34d7, 0x36ed, 0x38f0, + 0x3198, 0x3730, 0x31fa, 0x3439, 0x36a6, 0x3328, 0x38f5, 0x35f6, 0x3997, 0x3246, 0x3958, 0x3542, + 0x3890, 0x35b2, 0x387b, 0x364e, 0x391c, 0x3450, 0x199d, 0x382c, 0x2bc0, 0x31bf, 0x3af2, 0x344d, + 0x337a, 0x3b3d, 0x3a13, 0x2cc4, 0x3b74, 0x20b2, 0x3821, 0x34db, 0x391f, 0x3867, 0x3867, 0x351a, + 0x3920, 0x340d, 0x3918, 0x37dc, 0x395d, 0x344f, 0x398d, 0x3af1, 0x2688, 0x3884, 0x36d1, 0x37d5, + 0x3a83, 0x34fc, 0x32ef, 0x32a7, 0x3b70, 0x254c, 0x3255, 0x3ae5, 0x3b20, 0x355d, 0x31a2, 0x35c7, + 0x32e5, 0x367a, 0x3a16, 0x3b28, 0x2515, 0x3713, 0x2c86, 0x3461, 0x38e4, 0x39ca, 0x39ae, 0x337d, + 0x3a52, 0x3b23, 0x31a8, 0x250b, 0x376c, 0x381e, 0x34c6, 0x39ef, 0x3236, 0x1de2, 0x38c3, 0x330c, + 0x3a33, 0x38c8, 0x310c, 0x3716, 0x3762, 0x39b5, 0x3942, 0x37c6, 0x2a62, 0x37e8, 0x348a, 0x345e, + 0x331a, 0x3435, 0x39af, 0x38c4, 0x3bb0, 0x39c8, 0x30a1, 0x39ce, 0x3bc5, 0x3654, 0x29c8, 0x31c9, + 0x36c8, 0x3b42, 0x3a78, 0x3940, 0x3a71, 0x3516, 0x3bf8, 0x38c3, 0x3b8e, 0x31be, 0x3b8c, 0x2fba, + 0x3775, 0x353b, 0x3b07, 0x3a38, 0x383b, 0x3bb5, 0x39aa, 0x35b9, 0x34fe, 0x38e0, 0x2ec4, 0x3599, + 0x2f25, 0x3285, 0x319a, 0x29b8, 0x3997, 0x3945, 0x3bab, 0x3bd9, 0x382e, 0x3a0b, 0x3ab9, 0x3b34, + 0x39e1, 0x3912, 0x368e, 0x3b3b, 0x3ba9, 0x3ad4, 0x3a09, 0x384d, 0x3be3, 0x2af7, 0x3a54, 0x3be8, + 0x3082, 0x3165, 0x32c9, 0x3650, 0x3919, 0x3be0, 0x3728, 0x3b0c, 0x2be8, 0x36a5, 0x3b7d, 0x3898, + 0x3884, 0x34a1, 0x3060, 0x379f, 0x3bca, 0x3844, 0x3858, 0x38fa, 0x3062, 0x2c79, 0x3592, 0x3678, + 0x396a, 0x2b91, 0x3845, 0x350e, 0x3b4a, 0x341c, 0x34cd, 0x3928, 0x3b92, 0x39da, 0x313f, 0x3577, + 0x3a10, 0x39db, 0x382c, 0x3826, 0x31c0, 0x376e, 0x3186, 0x28f4, 0x2e8f, 0x394a, 0x3947, 0x36d7, + 0x2522, 0x3449, 0x3802, 0x3b78, 0x34c1, 0x29b0, 0x3705, 0x2e2e, 0x31ed, 0x3aba, 0x3849, 0x3acf, + 0x3878, 0x1fe7, 0x2e77, 0x300d, 0x328e, 0x3001, 0x1e21, 0x3a86, 0x38ef, 0x387d, 0x3b80, 0x3995, + 0x284d, 0x397e, 0x2fcb, 0x39ca, 0x331c, 0x2c0c, 0x36f1, 0x3a96, 0x3b50, 0x3a75, 0x3763, 0x3a84, + 0x3960, 0x2708, 0x3b84, 0x3ade, 0x351d, 0x362e, 0x3bbe, 0x369d, 0x3987, 0x3bbe, 0x3561, 0x2da4, + 0x37d4, 0x3abd, 0x38f2, 0x3a62, 0x3862, 0x29a1, 0x3a16, 0x3b7b, 0x36a6, 0x340d, 0x35f9, 0x3a2b, + 0x304d, 0x3bf3, 0x3870, 0x3446, 0x3a16, 0x3a41, 0x3564, 0x3aa0, 0x3ab1, 0x394e, 0x35b4, 0x34d9, + 0x3a36, 0x3b53, 0x382d, 0x3b15, 0x3651, 0x2f8f, 0x38a6, 0x2e0a, 0x34e5, 0x37f5, 0x2e90, 0x3500, + 0x3b11, 0x35e8, 0x2e48, 0x3b35, 0x3884, 0x3807, 0x2f0d, 0x3b1c, 0x3bce, 0x3752, 0x2b0b, 0x33d2, + 0x390e, 0x364d, 0x3373, 0x3a2c, 0x3839, 0x3286, 0x2825, 0x333a, 0x3b28, 0x3670, 0x3b28, 0x38fa, + 0x3acb, 0x392c, 0x394a, 0x3bb4, 0x3697, 0x2e8a, 0x34a7, 0x38ac, 0x3721, 0x38e7, 0x3ae3, 0x387a, + 0x372e, 0x394a, 0x2ff1, 0x3b45, 0x3b28, 0x3a78, 0x3bca, 0x39b5, 0x3882, 0x3225, 0x38aa, 0x3afc, + 0x3bba, 0x3335, 0x3b00, 0x31a0, 0x3178, 0x3897, 0x33f6, 0x3b92, 0x3a1f, 0x38f1, 0x3465, 0x333d, + 0x3873, 0x3645, 0x3963, 0x3b4d, 0x3458, 0x3a0b, 0x34b5, 0x3830, 0x34e3, 0x398d, 0x3b99, 0x3b94, + 0x3402, 0x3a05, 0x3a63, 0x33eb, 0x3651, 0x2f1b, 0x3bb1, 0x3ab8, 0x38d5, 0x35cf, 0x38b4, 0x398e, + 0x3bd9, 0x304c, 0x3a0e, 0x39c0, 0x3b38, 0x3170, 0x31f5, 0x3898, 0x3893, 0x329a, 0x364a, 0x3767, + 0x3064, 0x3423, 0x3ae4, 0x3b26, 0x3b29, 0x344e, 0x3974, 0x3944, 0x3515, 0x3990, 0x3857, 0x3595, + 0x3a48, 0x3862, 0x377e, 0x380e, 0x3526, 0x3b5e, 0x3350, 0x308c, 0x26d3, 0x3a18, 0x3af5, 0x3a8f, + 0x38f5, 0x3854, 0x3aa2, 0x3479, 0x383a, 0x211d, 0x34fc, 0x39d9, 0x35a8, 0x3904, 0x3b93, 0x33bd, + 0x32c1, 0x320d, 0x3abf, 0x23ff, 0x30f6, 0x360c, 0x35ef, 0x39ed, 0x3b66, 0x3a6f, 0x3021, 0x3a89, + 0x354e, 0x3a96, 0x3889, 0x3b4d, 0x3af6, 0x2c6c, 0x3a7f, 0x3aac, 0x32be, 0x3830, 0x3884, 0x39be, + 0x38c2, 0x2c1b, 0x39be, 0x3a92, 0x39b1, 0x373d, 0x3b89, 0x3933, 0x2c42, 0x3799, 0x3818, 0x394d, + 0x380c, 0x38b9, 0x327d, 0x39cc, 0x36ff, 0x386f, 0x305d, 0x39c9, 0x3b74, 0x3817, 0x3a3d, 0x221a, + 0x3ae8, 0x3804, 0x3977, 0x3959, 0x339a, 0x3822, 0x3967, 0x2e0f, 0x2ffe, 0x38b1, 0x3ae5, 0x3042, + 0x37c6, 0x3bc8, 0x3913, 0x3b46, 0x3ab4, 0x251a, 0x38ca, 0x3312, 0x3adf, 0x3881, 0x3511, 0x2c81, + 0x39ed, 0x2af6, 0x31ff, 0x3953, 0x3884, 0x3886, 0x2d46, 0x3860, 0x3b80, 0x351b, 0x3bd6, 0x34cf, + 0x3b2e, 0x3ab5, 0x3889, 0x24ee, 0x292d, 0x3a3c, 0x3522, 0x3956, 0x3627, 0x3437, 0x2ffc, 0x3742, + 0x38c9, 0x317e, 0x3866, 0x3a91, 0x38e6, 0x2eae, 0x39a9, 0x33dd, 0x389e, 0x397e, 0x3a4b, 0x3b82, + 0x35c6, 0x3baf, 0x34f6, 0x3273, 0x262b, 0x3a22, 0x3bdd, 0x38ce, 0x3893, 0x3ad5, 0x288b, 0x3821, + 0x35ae, 0x3857, 0x3754, 0x3a0f, 0x307b, 0x3938, 0x2cb8, 0x36d8, 0x39d8, 0x33ce, 0x3593, 0x3275, + 0x38ca, 0x3a55, 0x39de, 0x3219, 0x393c, 0x3be7, 0x30dc, 0x2a0d, 0x302c, 0x352a, 0x3af5, 0x3817, + 0x3ba0, 0x3a10, 0x35fa, 0x3552, 0x3820, 0x35c3, 0x381a, 0x3692, 0x3a0a, 0x3510, 0x35be, 0x360e, + 0x33cb, 0x3961, 0x3748, 0x383b, 0x39ee, 0x3713, 0x389b, 0x3a0c, 0x38dc, 0x3bcb, 0x35c0, 0x3ac6, + 0x3469, 0x3aea, 0x371f, 0x3040, 0x3653, 0x3811, 0x3b65, 0x3a43, 0x3bca, 0x329a, 0x3a68, 0x344a, + 0x3b87, 0x24cd, 0x31e4, 0x37f2, 0x3995, 0x36b8, 0x34c5, 0x3844, 0x2b59, 0x36b7, 0x375b, 0x2e4d, + 0x3397, 0x1c22, 0x3764, 0x343a, 0x3bb3, 0x365c, 0x343e, 0x381e, 0x3886, 0x370c, 0x386c, 0x35aa, + 0x357a, 0x395b, 0x3bf4, 0x37fd, 0x3aae, 0x3b37, 0x35dd, 0x3944, 0x3a71, 0x3832, 0x3a3d, 0x34d8, + 0x3a1c, 0x38db, 0x3ab2, 0x3ba3, 0x3255, 0x3886, 0x38b3, 0x316a, 0x3845, 0x33e0, 0x3bf6, 0x390c, + 0x3aea, 0x3b84, 0x349c, 0x395d, 0x3bdb, 0x3b01, 0x384e, 0x350f, 0x389f, 0x33c4, 0x2fea, 0x3860, + 0x32de, 0x31b9, 0x3ab2, 0x3825, 0x3afd, 0x3901, 0x3bf4, 0x2770, 0x336e, 0x3b99, 0x38d9, 0x3838, + 0x3650, 0x398a, 0x3868, 0x2d09}; + +uint16_t z_out[M_SIZE * K_SIZE] = { + 0x4cae, 0x4ccb, 0x4b76, 0x4c61, 0x4cca, 0x4cc8, 0x4a6b, 0x4c88, 0x4d1d, 0x4d15, 0x4c5b, 0x4c8e, + 0x4ca5, 0x4c76, 0x4c44, 0x4bfb, 0x4cab, 0x4cc4, 0x4cb6, 0x4c70, 0x4c55, 0x4bcf, 0x4c40, 0x4c0a, + 0x4d1d, 0x4cf2, 0x4c98, 0x4cc9, 0x4bef, 0x4c5f, 0x4cb2, 0x4c93, 0x4c0c, 0x4c4e, 0x4c42, 0x4c61, + 0x4c5a, 0x4cea, 0x4c15, 0x4c67, 0x4ca2, 0x4d8c, 0x4bfd, 0x4cb4, 0x4c34, 0x4c68, 0x4cc2, 0x4c23, + 0x4cd9, 0x4cdf, 0x4d72, 0x4d11, 0x4d1a, 0x4c03, 0x4cca, 0x4c40, 0x4c5a, 0x4ccc, 0x4c1f, 0x4c43, + 0x4c1c, 0x4c4b, 0x4c60, 0x4c4c, 0x4c03, 0x4bbb, 0x4b15, 0x4c04, 0x4c6d, 0x4c20, 0x4ad4, 0x4bf4, + 0x4c60, 0x4c72, 0x4bb7, 0x4c61, 0x4bc2, 0x4c01, 0x4c0e, 0x4b08, 0x4c84, 0x4c3a, 0x4c66, 0x4c0f, + 0x4bdc, 0x4c0c, 0x4bd6, 0x4bbf, 0x4cc2, 0x4c0d, 0x4c1d, 0x4c32, 0x4ad3, 0x4c05, 0x4c37, 0x4c0c, + 0x4c05, 0x4b84, 0x4bd2, 0x4c0a, 0x4b9e, 0x4ce4, 0x4bd9, 0x4bc7, 0x4c73, 0x4d5c, 0x4b9a, 0x4c85, + 0x4bda, 0x4bda, 0x4c64, 0x4b24, 0x4c7d, 0x4c20, 0x4d02, 0x4c8d, 0x4ca7, 0x4b62, 0x4c51, 0x4afc, + 0x4b37, 0x4bcd, 0x4b53, 0x4b13, 0x4b52, 0x4c02, 0x4c0c, 0x4bfd, 0x4c32, 0x4c11, 0x4a40, 0x4ca2, + 0x4c22, 0x4c19, 0x4aa7, 0x4c01, 0x4c34, 0x4c47, 0x4b32, 0x4ca8, 0x4be5, 0x4c1d, 0x4bd4, 0x4ac4, + 0x4c8d, 0x4c32, 0x4cc2, 0x4bba, 0x4c1a, 0x4b7c, 0x4ba5, 0x4be5, 0x4cbb, 0x4c33, 0x4c3d, 0x4c48, + 0x4b43, 0x4c24, 0x4c1d, 0x4c40, 0x4baa, 0x4ba8, 0x4b98, 0x4bcd, 0x4bce, 0x4cba, 0x4b7d, 0x4b8d, + 0x4bb5, 0x4ce4, 0x4b96, 0x4ca0, 0x4c24, 0x4c05, 0x4cc7, 0x4af7, 0x4c64, 0x4c80, 0x4cca, 0x4c7e, + 0x4ccf, 0x4b75, 0x4c31, 0x4c0f, 0x4bd6, 0x4c06, 0x4b15, 0x4be4, 0x4b63, 0x4c2e, 0x4b47, 0x4c52, + 0x4c61, 0x4c53, 0x4bdc, 0x4c9e, 0x4cb4, 0x4c28, 0x4a1a, 0x4c0c, 0x4c94, 0x4cac, 0x4bb2, 0x4c60, + 0x4c60, 0x4c3a, 0x4c62, 0x4a97, 0x4cd8, 0x4c64, 0x4c99, 0x4c28, 0x4c53, 0x4c24, 0x4c07, 0x4c4d, + 0x4cd1, 0x4c6c, 0x4c6f, 0x4c73, 0x4b8a, 0x4c95, 0x4c90, 0x4c2b, 0x4c0f, 0x4c51, 0x4c4a, 0x4bd4, + 0x4c50, 0x4c9e, 0x4ba5, 0x4c36, 0x4c49, 0x4d47, 0x4b7a, 0x4cca, 0x4c3c, 0x4c35, 0x4ce2, 0x4b3c, + 0x4c5a, 0x4c4f, 0x4cc7, 0x4ca3, 0x4ccf, 0x4c15, 0x4cc2, 0x4b99, 0x4c7b, 0x4c27, 0x4c10, 0x4c48, + 0x4c00, 0x4c6a, 0x4c52, 0x4c54, 0x4b09, 0x4c19, 0x4a32, 0x4bc4, 0x4b3b, 0x4af8, 0x49d4, 0x4b72, + 0x4bfc, 0x4c0c, 0x4b36, 0x4c1f, 0x4acf, 0x4ae5, 0x4b09, 0x4a81, 0x4c33, 0x4b6a, 0x4c3a, 0x4b95, + 0x4b12, 0x4a77, 0x4afd, 0x4ab9, 0x4c3d, 0x4c0b, 0x4c00, 0x4bad, 0x4acd, 0x4b40, 0x4b1f, 0x4b86, + 0x4a9f, 0x4aa4, 0x4b2b, 0x4ab9, 0x4b6a, 0x4c6a, 0x4b4c, 0x4abe, 0x4bba, 0x4cb2, 0x4a99, 0x4c50, + 0x4b3f, 0x4b4b, 0x4b6f, 0x4a6d, 0x4bf7, 0x4c26, 0x4c1b, 0x4c46, 0x4c10, 0x4af4, 0x4b77, 0x4b2f, + 0x4acb, 0x4be8, 0x4b0a, 0x4a7b, 0x4a5e, 0x4b2a, 0x4af3, 0x4bea, 0x4b46, 0x4b98, 0x4abb, 0x4c19, + 0x4bc9, 0x4b2d, 0x499b, 0x4b6f, 0x4c1f, 0x4b9c, 0x4aeb, 0x4c1c, 0x4b8e, 0x4b2c, 0x4b8f, 0x4aca, + 0x4c3f, 0x4bad, 0x4bf1, 0x4b87, 0x4b96, 0x4a84, 0x4a5a, 0x4b89, 0x4c13, 0x4b8e, 0x4c2b, 0x4bf6, + 0x4a6a, 0x4b77, 0x4be1, 0x4b9a, 0x4b1f, 0x4b31, 0x4b70, 0x4bac, 0x4b4d, 0x4c2c, 0x4add, 0x4b65, + 0x4c06, 0x4caf, 0x4aa0, 0x4c08, 0x4b12, 0x4b39, 0x4c44, 0x4a6b, 0x4c29, 0x4c52, 0x4c3e, 0x4c5a, + 0x4c33, 0x4b10, 0x4c1f, 0x4ae2, 0x4b0e, 0x4b71, 0x4a89, 0x4a77, 0x4a9c, 0x4b4a, 0x4bdc, 0x4b63, + 0x4cbe, 0x4cb1, 0x4b09, 0x4c40, 0x4c9a, 0x4c57, 0x4ad0, 0x4c53, 0x4c7c, 0x4d12, 0x4ba9, 0x4c7e, + 0x4c5c, 0x4c66, 0x4c70, 0x4b6d, 0x4d01, 0x4cac, 0x4cd0, 0x4c5f, 0x4c6c, 0x4c34, 0x4c78, 0x4b44, + 0x4d37, 0x4cc4, 0x4c82, 0x4ca9, 0x4b49, 0x4c60, 0x4c6f, 0x4c22, 0x4c1e, 0x4c02, 0x4c30, 0x4c8a, + 0x4c4e, 0x4cda, 0x4c3a, 0x4bdd, 0x4c80, 0x4db8, 0x4c43, 0x4ca3, 0x4c22, 0x4c30, 0x4ce0, 0x4bf5, + 0x4cdf, 0x4cba, 0x4d1c, 0x4cb2, 0x4d1c, 0x4c19, 0x4c9a, 0x4c31, 0x4c7d, 0x4c9b, 0x4c2d, 0x4ba7, + 0x4bb1, 0x4bcf, 0x4bf2, 0x4c5b, 0x4c67, 0x4c41, 0x4b75, 0x4bea, 0x4c38, 0x4b9e, 0x4a3c, 0x4c4f, + 0x4ca1, 0x4c5d, 0x4b7a, 0x4c28, 0x4c51, 0x4bf3, 0x4ba7, 0x4b09, 0x4c56, 0x4bbb, 0x4c3e, 0x4c0d, + 0x4c27, 0x4bc6, 0x4ab4, 0x4c0c, 0x4c71, 0x4c48, 0x4c59, 0x4ca1, 0x4bb3, 0x4c22, 0x4c2e, 0x4c16, + 0x4bff, 0x4bfb, 0x4c36, 0x4c3a, 0x4c1b, 0x4c70, 0x4ae9, 0x4c24, 0x4c81, 0x4d0a, 0x4abf, 0x4d06, + 0x4be2, 0x4bc3, 0x4c26, 0x4ac5, 0x4c0c, 0x4c65, 0x4cf1, 0x4cbb, 0x4c23, 0x4c60, 0x4c98, 0x4bc7, + 0x4b49, 0x4c2e, 0x4b94, 0x4b44, 0x4b1e, 0x4c02, 0x4c27, 0x4c46, 0x4c2a, 0x4c46, 0x4b5a, 0x4cd2, + 0x4c98, 0x4c39, 0x4a99, 0x4c50, 0x4c86, 0x4c8a, 0x4c13, 0x4d25, 0x4c02, 0x4c5d, 0x4c36, 0x4b82, + 0x4d1f, 0x4ca8, 0x4cc1, 0x4c4f, 0x4c46, 0x4c44, 0x4c02, 0x4c1c, 0x4ceb, 0x4ced, 0x4ca5, 0x4ca5, + 0x4b99, 0x4c46, 0x4c6a, 0x4cb6, 0x4c02, 0x4c2c, 0x4c41, 0x4c93, 0x4c50, 0x4ca0, 0x4c36, 0x4c1d, + 0x4c70, 0x4dc3, 0x4be2, 0x4ce9, 0x4bd5, 0x4c0b, 0x4d2d, 0x4b41, 0x4caa, 0x4ccc, 0x4ce3, 0x4d4f, + 0x4d21, 0x4c6d, 0x4cd0, 0x4c1c, 0x4c3f, 0x4c62, 0x4bcb, 0x4c2e, 0x4c0b, 0x4c8f, 0x4c6d, 0x4c94, + 0x4bcc, 0x4c47, 0x4b9d, 0x4c79, 0x4c5e, 0x4c21, 0x4afc, 0x4c5c, 0x4c94, 0x4c82, 0x4c11, 0x4c6c, + 0x4c29, 0x4c38, 0x4c1b, 0x4b9f, 0x4cae, 0x4bd2, 0x4d04, 0x4c29, 0x4c02, 0x4bba, 0x4af8, 0x4b58, + 0x4ca4, 0x4c94, 0x4ca5, 0x4c71, 0x4b62, 0x4c3f, 0x4c31, 0x4c2c, 0x4b5c, 0x4b67, 0x4c1e, 0x4c46, + 0x4c03, 0x4caf, 0x4c20, 0x4bd6, 0x4c75, 0x4d25, 0x4b95, 0x4c9c, 0x4c4d, 0x4bef, 0x4c8f, 0x4b61, + 0x4c3c, 0x4c8e, 0x4c92, 0x4cb0, 0x4cda, 0x4c3b, 0x4c48, 0x4bbb, 0x4c3b, 0x4c3d, 0x4c02, 0x4be5, + 0x4be0, 0x4b9f, 0x4c2a, 0x4c45, 0x4c2d, 0x4c14, 0x4b82, 0x4c73, 0x4cb5, 0x4c0d, 0x4a21, 0x4c71, + 0x4c07, 0x4c4e, 0x4b3f, 0x4c77, 0x4c32, 0x4bbf, 0x4c11, 0x4b4f, 0x4c74, 0x4c5e, 0x4c57, 0x4c1e, + 0x4c11, 0x4b77, 0x4b28, 0x4c5e, 0x4c9a, 0x4c74, 0x4c5d, 0x4c5e, 0x4abe, 0x4c22, 0x4bcc, 0x4bf8, + 0x4c1e, 0x4b60, 0x4c09, 0x4bce, 0x4c07, 0x4caa, 0x4b09, 0x4c52, 0x4c2d, 0x4d1a, 0x4b86, 0x4ca1, + 0x4b5d, 0x4c21, 0x4c9c, 0x4bae, 0x4c33, 0x4c4b, 0x4cf1, 0x4c63, 0x4ce2, 0x4bf0, 0x4c4c, 0x4b4c, + 0x4c1f, 0x4c53, 0x4b8a, 0x4b6d, 0x4bc2, 0x4b82, 0x4c58, 0x4bfb, 0x4c33, 0x4c80, 0x4aa0, 0x4c2d, + 0x4bfc, 0x4b90, 0x4acc, 0x4c24, 0x4be9, 0x4c90, 0x4b53, 0x4c8c, 0x4c6f, 0x4c4b, 0x4be5, 0x4b6b, + 0x4c86, 0x4c19, 0x4c81, 0x4bf9, 0x4c0a, 0x4bb7, 0x4c0f, 0x4ba5, 0x4c7f, 0x4c69, 0x4c40, 0x4c4e, + 0x4b0b, 0x4c2e, 0x4be4, 0x4c24, 0x4b28, 0x4bbe, 0x4b54, 0x4be7, 0x4b75, 0x4c6d, 0x4b4c, 0x4b9e, + 0x4b94, 0x4d21, 0x4bb2, 0x4c4b, 0x4c36, 0x4c29, 0x4ca8, 0x4a79, 0x4c60, 0x4c7b, 0x4cd5, 0x4c5e, + 0x4c7e, 0x4bfa, 0x4c6d, 0x4c07, 0x4c32, 0x4c84, 0x4b33, 0x4b03, 0x4bfe, 0x4b59, 0x4bf8, 0x4c1c, + 0x4c66, 0x4c84, 0x4c04, 0x4c94, 0x4ca2, 0x4c49, 0x4aa3, 0x4c6a, 0x4c79, 0x4ce0, 0x4c08, 0x4ca5, + 0x4c9f, 0x4c5b, 0x4c82, 0x4bc4, 0x4cf1, 0x4c54, 0x4c92, 0x4c50, 0x4c8e, 0x4c5c, 0x4c16, 0x4ccd, + 0x4d23, 0x4cb6, 0x4c97, 0x4cc1, 0x4c07, 0x4c5d, 0x4c3d, 0x4c29, 0x4c2f, 0x4c08, 0x4c6b, 0x4c1f, + 0x4c27, 0x4ccf, 0x4c2d, 0x4c3a, 0x4c6c, 0x4d64, 0x4bd8, 0x4d0a, 0x4c5d, 0x4c37, 0x4ceb, 0x4c3b, + 0x4c51, 0x4d00, 0x4d3f, 0x4cbc, 0x4cfd, 0x4c19, 0x4cca, 0x4c45, 0x4c69, 0x4c78, 0x4c0f, 0x4c39, + 0x4c21, 0x4c72, 0x4c3a, 0x4c57, 0x4c9c, 0x4c67, 0x4b98, 0x4c57, 0x4ca5, 0x4c0d, 0x4a8d, 0x4c38, + 0x4cac, 0x4ca5, 0x4c46, 0x4c7d, 0x4c86, 0x4c60, 0x4c1d, 0x4ade, 0x4cb4, 0x4cae, 0x4c75, 0x4c45, + 0x4c73, 0x4c65, 0x4b9f, 0x4c0c, 0x4d38, 0x4cae, 0x4c5d, 0x4c8c, 0x4b7f, 0x4c32, 0x4c64, 0x4c99, + 0x4c4c, 0x4c31, 0x4c30, 0x4c4f, 0x4c8d, 0x4cec, 0x4bcc, 0x4c03, 0x4c9d, 0x4d85, 0x4c34, 0x4cde, + 0x4be9, 0x4ba6, 0x4cae, 0x4c02, 0x4c8d, 0x4ca9, 0x4dae, 0x4cb7, 0x4ca3, 0x4c39, 0x4cab, 0x4bc6, + 0x4c06, 0x4c93, 0x4c02, 0x4bfa, 0x4c03, 0x4c16, 0x4c35, 0x4cb4, 0x4bff, 0x4bfc, 0x4aa3, 0x4bbf, + 0x4bf6, 0x4c1b, 0x4abd, 0x4b76, 0x4c4b, 0x4c4f, 0x4b28, 0x4c45, 0x4bdc, 0x4b5f, 0x4bb4, 0x4ac7, + 0x4c8f, 0x4c0e, 0x4c7d, 0x4bc1, 0x4be2, 0x4bde, 0x4b36, 0x4ba3, 0x4ca0, 0x4c4f, 0x4bc2, 0x4c57, + 0x4b38, 0x4b88, 0x4bfe, 0x4bdb, 0x4be2, 0x4b7d, 0x4bfe, 0x4bfb, 0x4b0a, 0x4c64, 0x4baa, 0x4b50, + 0x4b96, 0x4d07, 0x4ac0, 0x4c2f, 0x4bdd, 0x4bfe, 0x4c97, 0x4a7f, 0x4c46, 0x4c52, 0x4c62, 0x4c8d, + 0x4c3e, 0x4bf1, 0x4c3b, 0x4b36, 0x4b97, 0x4c0f, 0x4a8e, 0x4bb1, 0x4ba8, 0x4c06, 0x4b64, 0x4bd5, + 0x4c62, 0x4c96, 0x4af4, 0x4bae, 0x4c5a, 0x4c67, 0x4b00, 0x4c96, 0x4cb1, 0x4c88, 0x4b84, 0x4c01, + 0x4c85, 0x4c4c, 0x4b5c, 0x4b6f, 0x4c59, 0x4c29, 0x4c4f, 0x4c7f, 0x4c58, 0x4c39, 0x4b0f, 0x4b00, + 0x4cd9, 0x4c4e, 0x4c18, 0x4c84, 0x4b26, 0x4c21, 0x4c4b, 0x4bc2, 0x4c54, 0x4bc8, 0x4bfa, 0x4c29, + 0x4c10, 0x4c64, 0x4b46, 0x4b96, 0x4c87, 0x4cfc, 0x4bed, 0x4c41, 0x4be1, 0x4b94, 0x4c66, 0x4ab8, + 0x4c67, 0x4c5b, 0x4ce1, 0x4c5c, 0x4c6d, 0x4c24, 0x4bf2, 0x4be5, 0x4c08, 0x4c89, 0x4b5f, 0x4c19, + 0x4b89, 0x4bd9, 0x4bfe, 0x4c2c, 0x4c3d, 0x4c57, 0x4afb, 0x4c1c, 0x4c44, 0x4c02, 0x49fb, 0x4c7b, + 0x4c7f, 0x4c50, 0x4bcd, 0x4c28, 0x4c47, 0x4c02, 0x4c26, 0x4ab7, 0x4c82, 0x4bc0, 0x4c88, 0x4bfe, + 0x4c5d, 0x4b3d, 0x4bf3, 0x4c02, 0x4cf6, 0x4c6e, 0x4c56, 0x4c72, 0x4b36, 0x4c23, 0x4be3, 0x4c74, + 0x4b48, 0x4bae, 0x4c56, 0x4c3b, 0x4c11, 0x4c85, 0x4c36, 0x4ba5, 0x4c66, 0x4d49, 0x4b72, 0x4c66, + 0x4c0b, 0x4ba4, 0x4c99, 0x4bb5, 0x4c83, 0x4c6f, 0x4c9b, 0x4c89, 0x4c7a, 0x4c38, 0x4ca5, 0x4b9e, + 0x4c0f, 0x4c78, 0x4c32, 0x4bc9, 0x4b27, 0x4b7b, 0x4bdc, 0x4c26, 0x4d0b, 0x4cad, 0x4b71, 0x4c51, + 0x4ccb, 0x4c4d, 0x4a85, 0x4c85, 0x4d21, 0x4cec, 0x4c3d, 0x4c82, 0x4c8e, 0x4cb7, 0x4c73, 0x4c14, + 0x4d34, 0x4cd6, 0x4cd9, 0x4c50, 0x4c45, 0x4c49, 0x4c46, 0x4c8a, 0x4d06, 0x4c73, 0x4c8e, 0x4cd9, + 0x4c62, 0x4c8a, 0x4c82, 0x4c99, 0x4c10, 0x4c3c, 0x4c6a, 0x4c64, 0x4ca5, 0x4cc1, 0x4c3c, 0x4c13, + 0x4c87, 0x4d88, 0x4c14, 0x4cb6, 0x4c56, 0x4cad, 0x4cfa, 0x4c58, 0x4c9e, 0x4cbf, 0x4d5b, 0x4cc7, + 0x4cd1, 0x4c61, 0x4c87, 0x4c2f, 0x4c51, 0x4ce2, 0x4c5e, 0x4c2e, 0x4bf5, 0x4c67, 0x4c6d, 0x4ce9, + 0x4c1c, 0x4be6, 0x4abe, 0x4bf0, 0x4c57, 0x4b7a, 0x4ab4, 0x4be5, 0x4c36, 0x4ca2, 0x4a7b, 0x4c31, + 0x4bf4, 0x4b0e, 0x4c0c, 0x4b4e, 0x4ca2, 0x4b99, 0x4c33, 0x4bf1, 0x4bdc, 0x4b64, 0x4bc3, 0x4bb7, + 0x4c66, 0x4c35, 0x4c0c, 0x4c47, 0x4ae4, 0x4b8d, 0x4c5e, 0x4ba2, 0x4c13, 0x4b55, 0x4b72, 0x4b70, + 0x4b6b, 0x4c64, 0x4b95, 0x4b0c, 0x4c52, 0x4d18, 0x4a67, 0x4c48, 0x4b8f, 0x4c06, 0x4c83, 0x4b3f, + 0x4c59, 0x4c6e, 0x4c94, 0x4c39, 0x4c64, 0x4be2, 0x4c21, 0x4ae5, 0x4b4e, 0x4c20, 0x4b17, 0x4bc5, + 0x4b4f, 0x4bd1, 0x4b3e, 0x4bbd, 0x4b81, 0x4bfa, 0x49d8, 0x4b10, 0x4bb9, 0x4b11, 0x4979, 0x4bb0, + 0x4b60, 0x4bb1, 0x4a30, 0x4b26, 0x4bb8, 0x4b4f, 0x4a84, 0x49a9, 0x4ba8, 0x4ac8, 0x4b9f, 0x4a85, + 0x4b99, 0x4a02, 0x4b05, 0x4ae0, 0x4c5f, 0x4b74, 0x4b52, 0x4b90, 0x4a50, 0x4b53, 0x4ab8, 0x4b59, + 0x4ab1, 0x4b20, 0x4b4c, 0x4a95, 0x4b0d, 0x4b74, 0x4a0a, 0x4aef, 0x4b68, 0x4c1d, 0x4a7c, 0x4c19, + 0x4b22, 0x4a7b, 0x4c1c, 0x4a5f, 0x4c12, 0x4b74, 0x4bab, 0x4bba, 0x4b58, 0x4af7, 0x4bde, 0x4b62, + 0x4b1c, 0x4b57, 0x4aba, 0x4ad8, 0x4a12, 0x4ae2, 0x4ab5, 0x4bbc, 0x4c74, 0x4c7e, 0x4b1e, 0x4bde, + 0x4c70, 0x4be5, 0x4a4c, 0x4c41, 0x4cae, 0x4c6b, 0x4b5f, 0x4c2b, 0x4bda, 0x4ba9, 0x4b7e, 0x4aae, + 0x4c8c, 0x4c12, 0x4c1c, 0x4b70, 0x4c0d, 0x4bbc, 0x4ae6, 0x4bc4, 0x4cac, 0x4c36, 0x4c0c, 0x4c03, + 0x4b94, 0x4c2a, 0x4c37, 0x4c5a, 0x4b76, 0x4bdb, 0x4bb5, 0x4c5b, 0x4c25, 0x4c62, 0x4b57, 0x4bda, + 0x4c32, 0x4cc3, 0x4b9f, 0x4c7f, 0x4b61, 0x4b75, 0x4c60, 0x4b0d, 0x4c11, 0x4ca1, 0x4d3f, 0x4c48, + 0x4ce7, 0x4c16, 0x4c36, 0x4bc6, 0x4c07, 0x4c63, 0x4b34, 0x4b28, 0x4b79, 0x4b4e, 0x4b95, 0x4c42, + 0x4bb9, 0x4b63, 0x4aaa, 0x4bb6, 0x4c0d, 0x4b40, 0x4a03, 0x4bad, 0x4c0e, 0x4c09, 0x4ac3, 0x4c05, + 0x4c30, 0x4c28, 0x4b7f, 0x4a71, 0x4bfc, 0x4c0c, 0x4bff, 0x4bf3, 0x4c0e, 0x4aad, 0x4b9b, 0x4b3e, + 0x4cb9, 0x4c66, 0x4c37, 0x4be1, 0x4a95, 0x4bba, 0x4bca, 0x4b76, 0x4ada, 0x4aeb, 0x4b74, 0x4c18, + 0x4b47, 0x4b58, 0x4b4f, 0x4b11, 0x4bfb, 0x4ce0, 0x4ad1, 0x4bd5, 0x4b3b, 0x4ae6, 0x4c5a, 0x4ac7, + 0x4c2f, 0x4c50, 0x4c32, 0x4c19, 0x4c16, 0x4ba8, 0x4bfa, 0x4bb2, 0x4c17, 0x4c09, 0x4b2b, 0x4b2e, + 0x4b24, 0x4b89, 0x4ac7, 0x4b20, 0x4c25, 0x4ccb, 0x4b85, 0x4c49, 0x4c69, 0x4c56, 0x4ae8, 0x4c46, + 0x4c9e, 0x4ccb, 0x4b58, 0x4cae, 0x4c46, 0x4be5, 0x4b90, 0x4bc2, 0x4c8a, 0x4c47, 0x4cca, 0x4c5c, + 0x4c68, 0x4c4e, 0x4c02, 0x4bfa, 0x4ce4, 0x4cb0, 0x4c65, 0x4c87, 0x4b89, 0x4c2d, 0x4c7e, 0x4c2d, + 0x4c12, 0x4c27, 0x4be3, 0x4c52, 0x4bde, 0x4ca1, 0x4c18, 0x4c00, 0x4cbf, 0x4d3e, 0x4c30, 0x4cb3, + 0x4c39, 0x4c02, 0x4cc4, 0x4b51, 0x4c4e, 0x4c9c, 0x4ce4, 0x4cf5, 0x4cc4, 0x4c0d, 0x4c65, 0x4c12, + 0x4c03, 0x4cb9, 0x4b3e, 0x4c04, 0x4c02, 0x4baa, 0x4bcb, 0x4c59, 0x4c02, 0x4c76, 0x4b21, 0x4c02, + 0x4c3e, 0x4c67, 0x4a53, 0x4be0, 0x4ca5, 0x4c62, 0x4a63, 0x4c65, 0x4c2c, 0x4c09, 0x4b71, 0x4aaa, + 0x4c1d, 0x4c14, 0x4c83, 0x4c00, 0x4bd9, 0x4b1b, 0x4af1, 0x4ba6, 0x4cd1, 0x4bfa, 0x4c33, 0x4c55, + 0x4be8, 0x4c02, 0x4c4c, 0x4be6, 0x4c1e, 0x4b9c, 0x4b85, 0x4b5b, 0x4be8, 0x4c83, 0x4ba6, 0x4bbe, + 0x4c19, 0x4cf9, 0x4b99, 0x4caf, 0x4c3e, 0x4c02, 0x4cf0, 0x4b26, 0x4c63, 0x4c6f, 0x4cc5, 0x4c6e, + 0x4c66, 0x4ab9, 0x4b7e, 0x4bde, 0x4bd2, 0x4c56, 0x4b82, 0x4bc2, 0x4aef, 0x4bf1, 0x4be9, 0x4c2c, + 0x4c0a, 0x4c7c, 0x4a5c, 0x4c0e, 0x4c2e, 0x4c02, 0x49f6, 0x4c1e, 0x4c1f, 0x4c94, 0x4b1a, 0x4bf1, + 0x4c44, 0x4b95, 0x4c43, 0x4b1a, 0x4c9d, 0x4c24, 0x4c57, 0x4c35, 0x4c55, 0x4b5e, 0x4ba7, 0x4c11, + 0x4c6b, 0x4bcb, 0x4c2d, 0x4c1b, 0x4a69, 0x4c15, 0x4c1f, 0x4be1, 0x4ba3, 0x4b87, 0x4c2c, 0x4bce, + 0x4bc7, 0x4c73, 0x4bbf, 0x4c08, 0x4c6d, 0x4d19, 0x4b01, 0x4c01, 0x4c17, 0x4b59, 0x4c3d, 0x4b6a, + 0x4c6a, 0x4bec, 0x4ca6, 0x4bf8, 0x4c99, 0x4bca, 0x4c89, 0x4b39, 0x4c1e, 0x4bd0, 0x4b8a, 0x4c13, + 0x4b84, 0x4c05, 0x4ae5, 0x4b6b, 0x4c40, 0x4c2b, 0x4b50, 0x4c8c, 0x4ca4, 0x4c50, 0x4a2b, 0x4c24, + 0x4c6e, 0x4d0e, 0x4c05, 0x4c94, 0x4bf8, 0x4ba9, 0x4c47, 0x4b24, 0x4ccb, 0x4c89, 0x4d06, 0x4b72, + 0x4c82, 0x4c2d, 0x4b80, 0x4bc6, 0x4ce7, 0x4cc9, 0x4c4e, 0x4c65, 0x4c12, 0x4c6e, 0x4c3e, 0x4c43, + 0x4c36, 0x4c05, 0x4c74, 0x4c3d, 0x4c30, 0x4ce6, 0x4c04, 0x4c4f, 0x4bfb, 0x4d5e, 0x4c03, 0x4d11, + 0x4c5d, 0x4c22, 0x4d07, 0x4b69, 0x4c48, 0x4c75, 0x4d61, 0x4cb2, 0x4ce8, 0x4c4a, 0x4c77, 0x4c22, + 0x4c34, 0x4c6d, 0x4c02, 0x4c32, 0x4b96, 0x4c3f, 0x4c0f, 0x4c3b, 0x4bd4, 0x4c2c, 0x4b93, 0x4c67, + 0x4c5b, 0x4c0a, 0x4ae5, 0x4c45, 0x4ca2, 0x4c6a, 0x4c13, 0x4c5e, 0x4be3, 0x4c14, 0x4be8, 0x4be9, + 0x4c96, 0x4c71, 0x4c97, 0x4c42, 0x4c01, 0x4bbd, 0x4bad, 0x4c07, 0x4cf0, 0x4ca5, 0x4c72, 0x4c45, + 0x4b3a, 0x4c46, 0x4be6, 0x4c63, 0x4bb4, 0x4be8, 0x4c29, 0x4c1e, 0x4be8, 0x4cb6, 0x4bba, 0x4bba, + 0x4c8c, 0x4d52, 0x4b5e, 0x4c6d, 0x4bda, 0x4b90, 0x4c95, 0x4b9a, 0x4ca5, 0x4cb7, 0x4c7e, 0x4cb2, + 0x4cd0, 0x4c0f, 0x4c8f, 0x4baa, 0x4bde, 0x4c09, 0x4b92, 0x4b78, 0x4c20, 0x4c37, 0x4c3e, 0x4c00, + 0x4c11, 0x4c12, 0x4ab3, 0x4bbf, 0x4c16, 0x4ab8, 0x498a, 0x4c04, 0x4be1, 0x4bc1, 0x4ad4, 0x4c11, + 0x4be8, 0x4b8d, 0x4b1a, 0x4aad, 0x4c62, 0x4c0b, 0x4c60, 0x4b08, 0x4bad, 0x4b6d, 0x4b93, 0x4bd8, + 0x4c39, 0x4c0d, 0x4be3, 0x4bf6, 0x4a94, 0x4bd3, 0x4bc6, 0x4c18, 0x4b21, 0x4b93, 0x4b79, 0x4bbc, + 0x4bb0, 0x4c1f, 0x4b07, 0x4bcf, 0x4bde, 0x4cc6, 0x4ac7, 0x4c6b, 0x4b51, 0x4b9d, 0x4c59, 0x4ae4, + 0x4c04, 0x4c14, 0x4c71, 0x4be6, 0x4c40, 0x4b5f, 0x4c18, 0x4a87, 0x4b5b, 0x4bd5, 0x4bc7, 0x4bc0, + 0x4ac9, 0x4bd7, 0x4b47, 0x4bfb, 0x4c5b, 0x4c3d, 0x4ba8, 0x4c2e, 0x4c75, 0x4c5c, 0x4a59, 0x4c0b, + 0x4cad, 0x4cb8, 0x4bc2, 0x4c77, 0x4c09, 0x4be5, 0x4c10, 0x4b93, 0x4c8d, 0x4c66, 0x4c93, 0x4c47, + 0x4bca, 0x4ba1, 0x4c08, 0x4baa, 0x4c92, 0x4c87, 0x4c41, 0x4c73, 0x4c01, 0x4c72, 0x4c10, 0x4bf0, + 0x4b5c, 0x4c04, 0x4c5a, 0x4be6, 0x4c1f, 0x4c61, 0x4bf3, 0x4c3c, 0x4c58, 0x4d04, 0x4b48, 0x4c6d, + 0x4c1c, 0x4b9d, 0x4c5d, 0x4be3, 0x4c28, 0x4cb2, 0x4cc8, 0x4c82, 0x4d45, 0x4c1c, 0x4c7a, 0x4b63, + 0x4c1b, 0x4c88, 0x4c3a, 0x4c2e, 0x4bbe, 0x4bd9, 0x4ba4, 0x4c06, 0x4bed, 0x4b88, 0x4a1d, 0x4ae5, + 0x4b55, 0x4b5d, 0x49e8, 0x4b86, 0x4b40, 0x4b88, 0x4a71, 0x4c14, 0x4b3e, 0x4b55, 0x4aa2, 0x4a13, + 0x4c16, 0x4bba, 0x4c42, 0x4af3, 0x4b3d, 0x4aef, 0x4a78, 0x4af2, 0x4bcc, 0x4b4e, 0x4b2d, 0x4be0, + 0x4ab1, 0x4baa, 0x4aeb, 0x4b3d, 0x4aeb, 0x4b5c, 0x4b1c, 0x4ba3, 0x4b10, 0x4b71, 0x4b56, 0x4a0a, + 0x4ad1, 0x4c75, 0x4a9a, 0x4b4b, 0x4b42, 0x4b32, 0x4c54, 0x4a1a, 0x4b76, 0x4b27, 0x4c49, 0x4b9a, + 0x4b81, 0x4b2e, 0x4b5f, 0x4a6b, 0x4aa2, 0x4b89, 0x4b7a, 0x4b4c, 0x4a8f, 0x4afa, 0x4add, 0x4b6c, + 0x4c23, 0x4ca1, 0x4b53, 0x4c83, 0x4c92, 0x4c4a, 0x4a54, 0x4c12, 0x4c7e, 0x4c97, 0x4c55, 0x4cc6, + 0x4c38, 0x4be8, 0x4be7, 0x4bd5, 0x4ca0, 0x4c83, 0x4cf2, 0x4c66, 0x4c33, 0x4c05, 0x4bd8, 0x4bf9, + 0x4cac, 0x4cce, 0x4c62, 0x4c74, 0x4bec, 0x4c41, 0x4c0f, 0x4c64, 0x4b96, 0x4bf1, 0x4c39, 0x4c82, + 0x4c02, 0x4cad, 0x4c69, 0x4c17, 0x4c61, 0x4d56, 0x4bfb, 0x4c61, 0x4bed, 0x4c02, 0x4cd9, 0x4ba6, + 0x4c02, 0x4ca3, 0x4ce5, 0x4cdb, 0x4d13, 0x4c24, 0x4c43, 0x4c12, 0x4c2b, 0x4c98, 0x4c26, 0x4c32, + 0x4c22, 0x4c1d, 0x4c09, 0x4c1e, 0x4c91, 0x4c4b, 0x4be4, 0x4c54, 0x4ca6, 0x4c16, 0x4af8, 0x4c4f, + 0x4cb9, 0x4cc8, 0x4c01, 0x4c6a, 0x4c72, 0x4c6c, 0x4c6e, 0x4ba1, 0x4cd8, 0x4c76, 0x4cc0, 0x4c56, + 0x4c77, 0x4c79, 0x4c2f, 0x4c64, 0x4cdd, 0x4c8c, 0x4c48, 0x4cb2, 0x4bc7, 0x4c46, 0x4c75, 0x4c0a, + 0x4c09, 0x4c70, 0x4c1f, 0x4c78, 0x4c39, 0x4c97, 0x4be1, 0x4bdf, 0x4c97, 0x4d67, 0x4ba7, 0x4ccb, + 0x4c35, 0x4c05, 0x4cde, 0x4b7f, 0x4cb4, 0x4c95, 0x4d04, 0x4cc9, 0x4d09, 0x4c77, 0x4c90, 0x4c41, + 0x4c0d, 0x4c39, 0x4bed, 0x4c24, 0x4c02, 0x4c87, 0x4c32, 0x4c3a, 0x4c12, 0x4c5a, 0x4aa0, 0x4c0e, + 0x4c3a, 0x4baa, 0x4a48, 0x4c1e, 0x4ca6, 0x4c74, 0x4ba9, 0x4c64, 0x4bf6, 0x4b18, 0x4b90, 0x4b7b, + 0x4cac, 0x4c0e, 0x4c90, 0x4c2b, 0x4c11, 0x4b1d, 0x4b6d, 0x4bd8, 0x4ccf, 0x4c0a, 0x4bc5, 0x4c84, + 0x4b7f, 0x4c0a, 0x4c30, 0x4bdd, 0x4b45, 0x4ad1, 0x4b9f, 0x4c19, 0x4bfb, 0x4c44, 0x4c46, 0x4b6f, + 0x4c60, 0x4cbd, 0x4b08, 0x4c6d, 0x4c04, 0x4c11, 0x4c12, 0x4af7, 0x4bab, 0x4c56, 0x4cad, 0x4c86, + 0x4c93, 0x4bc7, 0x4c2d, 0x4ad9, 0x4c06, 0x4c30, 0x4bae, 0x4ba4, 0x4afb, 0x4bb3, 0x4c09, 0x4b89, + 0x4c06, 0x4c63, 0x4b5d, 0x4c84, 0x4c06, 0x4bc8, 0x49ef, 0x4b95, 0x4c54, 0x4c42, 0x4b71, 0x4c32, + 0x4b52, 0x4b1e, 0x4af1, 0x4ae9, 0x4c9c, 0x4c25, 0x4c66, 0x4bfd, 0x4b67, 0x4bcd, 0x4af2, 0x4b7e, + 0x4c74, 0x4c29, 0x4b7e, 0x4c0a, 0x4b2a, 0x4c26, 0x4bb8, 0x4c07, 0x4bec, 0x4b71, 0x4b8f, 0x4b14, + 0x4bb2, 0x4c8e, 0x4beb, 0x4bac, 0x4bfb, 0x4ce0, 0x4b34, 0x4c21, 0x4be1, 0x4c03, 0x4c53, 0x4b86, + 0x4baf, 0x4c40, 0x4c98, 0x4c6c, 0x4c78, 0x4bfc, 0x4c15, 0x4b54, 0x4b6a, 0x4c30, 0x4be2, 0x4b3e, + 0x4b43, 0x4b15, 0x4bae, 0x4beb, 0x4b6a, 0x4bc9, 0x4ad8, 0x4c28, 0x4c3b, 0x4b99, 0x4968, 0x4c03, + 0x4c24, 0x4c33, 0x4ad3, 0x4c45, 0x4b18, 0x4b63, 0x4bb1, 0x4b29, 0x4c3e, 0x4baf, 0x4c04, 0x4b78, + 0x4bb4, 0x4af2, 0x4a83, 0x4c44, 0x4c67, 0x4c1e, 0x4bad, 0x4c2e, 0x4b07, 0x4bff, 0x4b1c, 0x4beb, + 0x4b00, 0x4b1c, 0x4bfe, 0x4b86, 0x4b6d, 0x4c09, 0x4b2e, 0x4ba4, 0x4c16, 0x4c94, 0x4b32, 0x4c2e, + 0x4b28, 0x4b2d, 0x4c35, 0x4b09, 0x4b4c, 0x4c25, 0x4c9c, 0x4c3a, 0x4c22, 0x4b95, 0x4c0a, 0x4af1, + 0x4b20, 0x4c3d, 0x4b79, 0x4b40, 0x4a9e, 0x4b52, 0x4c09, 0x4c03, 0x4c74, 0x4c1c, 0x4bc9, 0x4c74, + 0x4ccf, 0x4c62, 0x4ad2, 0x4c51, 0x4cbe, 0x4c92, 0x4bdf, 0x4c8e, 0x4c57, 0x4c0f, 0x4c13, 0x4b34, + 0x4ce0, 0x4c8a, 0x4ccc, 0x4bf7, 0x4c61, 0x4c6a, 0x4b81, 0x4bda, 0x4cf7, 0x4c7f, 0x4c58, 0x4c3a, + 0x4bc5, 0x4c5e, 0x4c5b, 0x4c7a, 0x4c09, 0x4c3a, 0x4c5c, 0x4c3d, 0x4c02, 0x4d0a, 0x4c29, 0x4bc8, + 0x4c98, 0x4d8b, 0x4b6a, 0x4c9b, 0x4c20, 0x4bfb, 0x4d3d, 0x4ba0, 0x4c7c, 0x4c82, 0x4cf2, 0x4d27, + 0x4cd0, 0x4c68, 0x4c8d, 0x4bdb, 0x4c29, 0x4c69, 0x4c08, 0x4c0a, 0x4b5d, 0x4bc8, 0x4c0d, 0x4c92, + 0x4c0e, 0x4c3f, 0x4be7, 0x4ca5, 0x4c4f, 0x4c20, 0x4b1d, 0x4c78, 0x4ca0, 0x4c56, 0x4c24, 0x4cc9, + 0x4c33, 0x4c49, 0x4c1d, 0x4b6b, 0x4ccd, 0x4c2e, 0x4c8d, 0x4c0b, 0x4c36, 0x4bf8, 0x4c20, 0x4c20, + 0x4d0a, 0x4caa, 0x4c6a, 0x4cfc, 0x4c00, 0x4c83, 0x4c4e, 0x4c51, 0x4bd1, 0x4c20, 0x4c5a, 0x4c23, + 0x4c15, 0x4ce6, 0x4bcf, 0x4c35, 0x4c46, 0x4d3d, 0x4bfd, 0x4ccb, 0x4c41, 0x4c07, 0x4cea, 0x4b69, + 0x4c6f, 0x4c8e, 0x4cfa, 0x4d22, 0x4cb5, 0x4c45, 0x4c7d, 0x4bb2, 0x4c3f, 0x4c42, 0x4be8, 0x4b9b, + 0x4c02, 0x4c41, 0x4ca7, 0x4c66, 0x4c6d, 0x4c2a, 0x4aa4, 0x4c4d, 0x4c66, 0x4bdd, 0x4a63, 0x4c28, + 0x4c8c, 0x4c75, 0x4b96, 0x4c2a, 0x4c12, 0x4c4c, 0x4c02, 0x4b1a, 0x4c83, 0x4c58, 0x4c9d, 0x4be6, + 0x4bdb, 0x4c28, 0x4c2f, 0x4be7, 0x4d14, 0x4cc4, 0x4c44, 0x4c63, 0x4b29, 0x4c02, 0x4c42, 0x4c30, + 0x4b95, 0x4c00, 0x4c51, 0x4c44, 0x4bf3, 0x4c43, 0x4bc4, 0x4c03, 0x4c4f, 0x4d51, 0x4b58, 0x4c66, + 0x4c14, 0x4b7b, 0x4ce0, 0x4baa, 0x4c5b, 0x4c9b, 0x4cd8, 0x4c76, 0x4c67, 0x4c22, 0x4c93, 0x4bb1, + 0x4c55, 0x4c5d, 0x4c40, 0x4c1d, 0x4bb1, 0x4c38, 0x4b7b, 0x4c6a, 0x4be8, 0x4caa, 0x4a58, 0x4c00, + 0x4c10, 0x4c03, 0x4b11, 0x4c63, 0x4c52, 0x4c94, 0x4b0d, 0x4c02, 0x4c1f, 0x4b84, 0x4bae, 0x4b3a, + 0x4c11, 0x4c3f, 0x4cca, 0x4be1, 0x4c03, 0x4c1c, 0x4b65, 0x4b62, 0x4c64, 0x4c31, 0x4bc5, 0x4c6c, + 0x4ba4, 0x4c48, 0x4c11, 0x4b6b, 0x4b61, 0x4baa, 0x4bec, 0x4c1f, 0x4b43, 0x4c65, 0x4c0a, 0x4bc5, + 0x4c19, 0x4d1c, 0x4bb6, 0x4c12, 0x4c27, 0x4be2, 0x4cb6, 0x4ab5, 0x4c93, 0x4c64, 0x4c93, 0x4cb1, + 0x4c8f, 0x4b64, 0x4c39, 0x4c1d, 0x4b9d, 0x4c48, 0x4b0b, 0x4b08, 0x4b8a, 0x4b85, 0x4b83, 0x4c19, + 0x4c15, 0x4c34, 0x4afb, 0x4c55, 0x4c72, 0x4c14, 0x4a7a, 0x4c3d, 0x4c7e, 0x4c27, 0x4b98, 0x4cc6, + 0x4c4f, 0x4b12, 0x4b2e, 0x4b60, 0x4c8d, 0x4c5b, 0x4c64, 0x4bee, 0x4c18, 0x4bcf, 0x4c1a, 0x4c2c, + 0x4ce1, 0x4c61, 0x4c0e, 0x4c26, 0x4b81, 0x4c08, 0x4c29, 0x4c23, 0x4bf0, 0x4be5, 0x4bcc, 0x4c3f, + 0x4c05, 0x4cbb, 0x4c30, 0x4b4e, 0x4c32, 0x4cff, 0x4b5a, 0x4c80, 0x4c15, 0x4bed, 0x4cd4, 0x4ab8, + 0x4c55, 0x4c89, 0x4cac, 0x4c9f, 0x4c75, 0x4c38, 0x4c44, 0x4be0, 0x4c16, 0x4c0b, 0x4c06, 0x4bd4, + 0x4b5b, 0x4bdc, 0x4bb6, 0x4c6c, 0x4b9d, 0x4bf7, 0x49d3, 0x4b5e, 0x4b8b, 0x4b8f, 0x4934, 0x4b77, + 0x4b7e, 0x4c32, 0x4a26, 0x4bf3, 0x4ba1, 0x4bf1, 0x4b35, 0x4a1d, 0x4c14, 0x4bf7, 0x4c37, 0x4b70, + 0x4b74, 0x4aac, 0x4b30, 0x4b86, 0x4c6d, 0x4c3e, 0x4bc0, 0x4bd7, 0x4a69, 0x4b39, 0x4b56, 0x4b2f, + 0x4b9b, 0x4b3f, 0x4b34, 0x4bcc, 0x4aec, 0x4c28, 0x4aa4, 0x4b77, 0x4b3d, 0x4c83, 0x4aa8, 0x4c24, + 0x4acc, 0x4b6e, 0x4c08, 0x4a66, 0x4be0, 0x4b77, 0x4ca6, 0x4bb5, 0x4c06, 0x4b1d, 0x4bdb, 0x4ad0, + 0x4bc7, 0x4b95, 0x4a55, 0x4b9d, 0x4b03, 0x4b57, 0x4b1f, 0x4b38, 0x4c38, 0x4c14, 0x4aa8, 0x4be2, + 0x4c4a, 0x4c2e, 0x4a73, 0x4c34, 0x4c56, 0x4c28, 0x4ac1, 0x4c35, 0x4c38, 0x4c0e, 0x4b84, 0x4a9e, + 0x4c4a, 0x4bfa, 0x4c84, 0x4c0e, 0x4be7, 0x4b78, 0x4c06, 0x4b71, 0x4cac, 0x4bef, 0x4c3e, 0x4c3a, + 0x4b20, 0x4b84, 0x4c1d, 0x4ba8, 0x4ba0, 0x4b94, 0x4ba3, 0x4c6c, 0x4bea, 0x4c4e, 0x4b9d, 0x4bac, + 0x4c2f, 0x4cd4, 0x4b6c, 0x4c2e, 0x4bfe, 0x4bea, 0x4c92, 0x4a89, 0x4c08, 0x4c61, 0x4c68, 0x4ca6, + 0x4ca9, 0x4c3e, 0x4c4e, 0x4b16, 0x4c05, 0x4c30, 0x4bc9, 0x4ba4, 0x4ad1, 0x4b2e, 0x4c2e, 0x4bf0, + 0x4ae3, 0x4b77, 0x4a5e, 0x4c28, 0x4b71, 0x4a92, 0x49f9, 0x4b3c, 0x4c0f, 0x4b47, 0x4ae8, 0x4bb9, + 0x4b1c, 0x4bb3, 0x4ac5, 0x4a9a, 0x4c46, 0x4b18, 0x4bed, 0x4b90, 0x4b06, 0x4ab9, 0x4ad8, 0x4ae3, + 0x4c74, 0x4bb4, 0x4b72, 0x4c13, 0x4aaf, 0x4b81, 0x4bf9, 0x4c00, 0x4b2e, 0x4aa8, 0x4b11, 0x4b5d, + 0x4ae6, 0x4bf3, 0x4a75, 0x4a9a, 0x4bd3, 0x4c38, 0x4b18, 0x4c09, 0x4b87, 0x4b2d, 0x4c14, 0x4a47, + 0x4b74, 0x4be8, 0x4c42, 0x4bc4, 0x4ba1, 0x4b2a, 0x4bc0, 0x4a4d, 0x4b16, 0x4bb4, 0x4afa, 0x4ad9, + 0x4ad7, 0x4b6c, 0x4aec, 0x4c15, 0x4c52, 0x4c38, 0x4b25, 0x4c30, 0x4c67, 0x4c3f, 0x4aa1, 0x4c05, + 0x4c3f, 0x4c7f, 0x4bb3, 0x4c5f, 0x4c4e, 0x4c6c, 0x4c27, 0x4aae, 0x4c58, 0x4c51, 0x4c7d, 0x4c0b, + 0x4c0e, 0x4c75, 0x4c24, 0x4bf9, 0x4c95, 0x4c3f, 0x4c6b, 0x4cb8, 0x4b50, 0x4c19, 0x4c6b, 0x4c06, + 0x4b56, 0x4c14, 0x4c17, 0x4c26, 0x4c07, 0x4c98, 0x4b96, 0x4c05, 0x4c2d, 0x4d1d, 0x4bcf, 0x4c1c, + 0x4c1a, 0x4c2c, 0x4ca5, 0x4b4c, 0x4c41, 0x4c2d, 0x4ced, 0x4ca1, 0x4c90, 0x4c29, 0x4c5d, 0x4bf9, + 0x4bf2, 0x4c99, 0x4c00, 0x4c08, 0x4bbf, 0x4c1d, 0x4c47, 0x4c19, 0x4c3a, 0x4c1a, 0x4aad, 0x4bd5, + 0x4c67, 0x4bf1, 0x4a82, 0x4c1b, 0x4c5a, 0x4c56, 0x4b0f, 0x4c65, 0x4c0b, 0x4bbc, 0x4c23, 0x4b60, + 0x4c59, 0x4c14, 0x4c76, 0x4bc5, 0x4b7d, 0x4b5b, 0x4bfd, 0x4c14, 0x4c33, 0x4be3, 0x4c5a, 0x4c48, + 0x4b37, 0x4c13, 0x4c17, 0x4c3d, 0x4bff, 0x4b70, 0x4bf4, 0x4c32, 0x4b75, 0x4c8f, 0x4b83, 0x4c01, + 0x4c09, 0x4ce4, 0x4afe, 0x4c4d, 0x4c00, 0x4c30, 0x4cb4, 0x4b21, 0x4c17, 0x4c0d, 0x4c5e, 0x4c51, + 0x4c43, 0x4bea, 0x4c15, 0x4b37, 0x4c23, 0x4c84, 0x4ae8, 0x4bf0, 0x4b64, 0x4bec, 0x4bf6, 0x4c00, + 0x4c53, 0x4c69, 0x4b9d, 0x4c3d, 0x4cb7, 0x4c4b, 0x4a48, 0x4c53, 0x4c8a, 0x4ca6, 0x4c09, 0x4c99, + 0x4c14, 0x4c2f, 0x4c2d, 0x4bb1, 0x4cb1, 0x4caf, 0x4cb0, 0x4bfb, 0x4c2b, 0x4beb, 0x4c2a, 0x4bfc, + 0x4cf2, 0x4cbc, 0x4c78, 0x4c78, 0x4bd1, 0x4c26, 0x4c54, 0x4c1e, 0x4bab, 0x4b93, 0x4bf0, 0x4c6f, + 0x4c4f, 0x4c78, 0x4b9f, 0x4c2c, 0x4c38, 0x4d2a, 0x4c12, 0x4c92, 0x4bcd, 0x4bf5, 0x4c6d, 0x4b11, + 0x4c39, 0x4c69, 0x4d44, 0x4cc8, 0x4c72, 0x4c24, 0x4c6b, 0x4c1a, 0x4b6a, 0x4c98, 0x4b8c, 0x4bd7, + 0x4bc6, 0x4c4c, 0x4bb4, 0x4c27, 0x4b2d, 0x4c8c, 0x4b01, 0x4c44, 0x4c6a, 0x4c4d, 0x4ae3, 0x4c2f, + 0x4c61, 0x4cbf, 0x4ad0, 0x4c4c, 0x4bf6, 0x4c0a, 0x4c0f, 0x4b2b, 0x4c3c, 0x4c41, 0x4c5a, 0x4b8f, + 0x4c3e, 0x4b85, 0x4c16, 0x4bac, 0x4c8d, 0x4c90, 0x4c64, 0x4c4d, 0x4b09, 0x4c16, 0x4c17, 0x4baa, + 0x4bbe, 0x4b8e, 0x4c3d, 0x4c18, 0x4bf2, 0x4c2d, 0x4bec, 0x4be0, 0x4ca8, 0x4d28, 0x4c17, 0x4c19, + 0x4bb1, 0x4beb, 0x4c87, 0x4b00, 0x4c1a, 0x4c7a, 0x4cf3, 0x4c58, 0x4c6b, 0x4b51, 0x4ca9, 0x4be0, + 0x4bf5, 0x4c74, 0x4b7b, 0x4c21, 0x4be0, 0x4c7f, 0x4c02, 0x4ba2, 0x4c0b, 0x4c3d, 0x4a97, 0x4b31, + 0x4c5c, 0x4b8d, 0x49bf, 0x4c1f, 0x4c1e, 0x4c74, 0x4a3a, 0x4c67, 0x4c5a, 0x4bc5, 0x4bfb, 0x4aee, + 0x4c94, 0x4c14, 0x4cb5, 0x4b73, 0x4c8c, 0x4ba2, 0x4bed, 0x4c0d, 0x4c8a, 0x4b9d, 0x4c1e, 0x4c6b, + 0x4aff, 0x4c22, 0x4c16, 0x4bd3, 0x4b3e, 0x4bf4, 0x4c13, 0x4c4a, 0x4bbf, 0x4c3b, 0x4b4f, 0x4c2c, + 0x4c14, 0x4cbf, 0x4b04, 0x4c6f, 0x4c12, 0x4c23, 0x4ce7, 0x4ab9, 0x4be9, 0x4c35, 0x4d11, 0x4c73, + 0x4c32, 0x4ba8, 0x4c66, 0x4b8d, 0x4bbf, 0x4c73, 0x4b79, 0x4b63, 0x4b0a, 0x4bfe, 0x4b86, 0x4c25, + 0x4c24, 0x4c1f, 0x4b14, 0x4c36, 0x4c74, 0x4c2f, 0x4a63, 0x4c9a, 0x4c8c, 0x4c4a, 0x4ba6, 0x4ca6, + 0x4c2f, 0x4bdc, 0x4bb5, 0x4bcc, 0x4c8b, 0x4c48, 0x4cb4, 0x4c5d, 0x4c0e, 0x4c0a, 0x4bab, 0x4c10, + 0x4c76, 0x4c47, 0x4c66, 0x4c9d, 0x4ae9, 0x4c10, 0x4c5b, 0x4c31, 0x4c06, 0x4b5d, 0x4c45, 0x4c2e, + 0x4c0c, 0x4c9b, 0x4bae, 0x4c33, 0x4c4b, 0x4d3a, 0x4bf9, 0x4c79, 0x4bff, 0x4bcb, 0x4ced, 0x4ba6, + 0x4c9d, 0x4c60, 0x4c7d, 0x4c9c, 0x4ca4, 0x4bb4, 0x4c9c, 0x4b74, 0x4b76, 0x4c6a, 0x4c18, 0x4bfe, + 0x4b8e, 0x4c2e, 0x4bec, 0x4c68, 0x4c22, 0x4baf, 0x4bca, 0x4c2f, 0x4c8d, 0x4c3d, 0x4a24, 0x4c27, + 0x4c4c, 0x4c9a, 0x4b60, 0x4c98, 0x4c32, 0x4c3b, 0x4c2e, 0x4b46, 0x4cc5, 0x4c3f, 0x4c61, 0x4c3f, + 0x4c31, 0x4be3, 0x4c0b, 0x4c28, 0x4cf1, 0x4c8d, 0x4c72, 0x4cad, 0x4b2d, 0x4c16, 0x4c16, 0x4c0f, + 0x4bd4, 0x4c53, 0x4c31, 0x4c1f, 0x4c56, 0x4c8b, 0x4bd2, 0x4bd3, 0x4bf7, 0x4d7d, 0x4aaf, 0x4ca8, + 0x4bca, 0x4c17, 0x4cc9, 0x4b8a, 0x4c7c, 0x4c69, 0x4c9b, 0x4ccd, 0x4ca3, 0x4c61, 0x4c62, 0x4b73, + 0x4c02, 0x4c6e, 0x4bbf, 0x4c1b, 0x4bfe, 0x4c21, 0x4c51, 0x4c17, 0x4c78, 0x4c6f, 0x4bd7, 0x4c8e, + 0x4cbb, 0x4c02, 0x4ae1, 0x4c40, 0x4c91, 0x4cd4, 0x4c10, 0x4ca2, 0x4c2a, 0x4c37, 0x4c3c, 0x4b9d, + 0x4d29, 0x4c57, 0x4cef, 0x4c6d, 0x4c8b, 0x4c2e, 0x4c41, 0x4cac, 0x4d1e, 0x4caf, 0x4cb8, 0x4c9b, + 0x4bcf, 0x4c60, 0x4c8f, 0x4c87, 0x4c1d, 0x4c63, 0x4c60, 0x4c7a, 0x4c33, 0x4cb3, 0x4c1b, 0x4c3a, + 0x4c8e, 0x4d56, 0x4ba9, 0x4d16, 0x4c47, 0x4c14, 0x4d3d, 0x4b8a, 0x4c9c, 0x4cef, 0x4cf1, 0x4cdc, + 0x4cdb, 0x4c66, 0x4caf, 0x4c06, 0x4c1c, 0x4c61, 0x4c11, 0x4c61, 0x4c27, 0x4c3d, 0x4c1e, 0x4ca7, + 0x4b13, 0x4bfe, 0x4a52, 0x4c22, 0x4c0e, 0x4b8f, 0x4a8e, 0x4b4a, 0x4b60, 0x4b8b, 0x4b2e, 0x4bb1, + 0x4ba5, 0x4aeb, 0x4ac8, 0x4a5c, 0x4c3e, 0x4b54, 0x4c24, 0x4b96, 0x4bfa, 0x4b9c, 0x4ada, 0x4adb, + 0x4c39, 0x4bb2, 0x4b4a, 0x4bbe, 0x4ad7, 0x4b7e, 0x4a7c, 0x4b4b, 0x4ae7, 0x4ad1, 0x4bea, 0x4b75, + 0x4ad3, 0x4c05, 0x4bb8, 0x4b0b, 0x4bc7, 0x4c7b, 0x4ba8, 0x4bae, 0x4b38, 0x4acb, 0x4c03, 0x4a42, + 0x4b0d, 0x4c2d, 0x4c57, 0x4c65, 0x4c48, 0x4bf9, 0x4b99, 0x4acd, 0x4b56, 0x4c44, 0x4aac, 0x4b91, + 0x4abe, 0x4ae5, 0x4ad9, 0x4b89, 0x4ab7, 0x4bd8, 0x4a93, 0x4b9e, 0x4bab, 0x4bd7, 0x49ed, 0x4bcd, + 0x4c8d, 0x4c29, 0x4a60, 0x4c25, 0x4b16, 0x4b37, 0x4b1a, 0x4abc, 0x4bb3, 0x4bb6, 0x4c10, 0x4b9a, + 0x4b80, 0x4ac0, 0x4a5c, 0x4af7, 0x4c4b, 0x4b5e, 0x4b71, 0x4bac, 0x4b6b, 0x4bbd, 0x4bb1, 0x4bd7, + 0x4b15, 0x4a87, 0x4b5c, 0x4bff, 0x4b6f, 0x4bf4, 0x4b44, 0x4ba6, 0x4c37, 0x4c78, 0x4a99, 0x4c46, + 0x4b85, 0x4aa2, 0x4c39, 0x4a7d, 0x4c41, 0x4c29, 0x4c36, 0x4c27, 0x4c54, 0x4b1e, 0x4bc0, 0x4a96, + 0x4b83, 0x4b9a, 0x4ad4, 0x4b1b, 0x4b29, 0x4b15, 0x4b45, 0x4ba3, 0x4c24, 0x4c01, 0x4b09, 0x4c14, + 0x4c19, 0x4b9f, 0x497e, 0x4bf8, 0x4c0f, 0x4c9d, 0x4b5c, 0x4c52, 0x4bc9, 0x4bf1, 0x4c0c, 0x4a46, + 0x4c86, 0x4b41, 0x4c7a, 0x4bbe, 0x4c6c, 0x4be4, 0x4b11, 0x4bce, 0x4ca5, 0x4c54, 0x4c24, 0x4c61, + 0x4aa6, 0x4c00, 0x4bb1, 0x4bf1, 0x4b07, 0x4c12, 0x4c01, 0x4b75, 0x4c0c, 0x4c54, 0x4b80, 0x4b88, + 0x4be0, 0x4cf2, 0x4aef, 0x4cc1, 0x4ba2, 0x4b41, 0x4c8a, 0x4a60, 0x4beb, 0x4c14, 0x4cbe, 0x4c8f, + 0x4c77, 0x4c41, 0x4c44, 0x4b83, 0x4b99, 0x4c17, 0x4b81, 0x4b46, 0x4ad7, 0x4b7a, 0x4b94, 0x4c35, + 0x4b67, 0x4c1d, 0x49e1, 0x4bb8, 0x4b7d, 0x4ab3, 0x49c1, 0x4b9e, 0x4bcb, 0x4c06, 0x4b37, 0x4baa, + 0x4b91, 0x4b00, 0x4afc, 0x4ac2, 0x4bf4, 0x4bd4, 0x4be3, 0x4b48, 0x4bcf, 0x4ac4, 0x4a57, 0x4ba5, + 0x4c4e, 0x4c1b, 0x4b31, 0x4be4, 0x4b26, 0x4bcb, 0x4b64, 0x4bf6, 0x4aff, 0x4b51, 0x4b4b, 0x4b3b, + 0x4ae3, 0x4c1d, 0x4a9b, 0x4abb, 0x4b15, 0x4c4f, 0x4a50, 0x4bf4, 0x4b93, 0x4a9f, 0x4bf1, 0x4a85, + 0x4bcb, 0x4c02, 0x4c6c, 0x4c15, 0x4be6, 0x4b42, 0x4bf3, 0x4b23, 0x4b6a, 0x4b73, 0x4a96, 0x4bbf, + 0x4af0, 0x4bc4, 0x4b1b, 0x4b7c, 0x4cc2, 0x4c87, 0x4a2c, 0x4c12, 0x4c3e, 0x4c34, 0x4abd, 0x4c38, + 0x4c43, 0x4ce1, 0x4b49, 0x4c5e, 0x4c5b, 0x4c5a, 0x4c47, 0x4b67, 0x4cad, 0x4c39, 0x4ca6, 0x4c67, + 0x4c0c, 0x4b1a, 0x4c03, 0x4c48, 0x4cb0, 0x4c42, 0x4c6b, 0x4cbf, 0x4c13, 0x4c36, 0x4c2a, 0x4c7e, + 0x4bcc, 0x4bda, 0x4c59, 0x4c2f, 0x4c36, 0x4c8b, 0x4b89, 0x4b7a, 0x4c65, 0x4cdc, 0x4b33, 0x4cd8, + 0x4c7b, 0x4c4a, 0x4cdd, 0x4c2d, 0x4c91, 0x4c9d, 0x4cc3, 0x4c79, 0x4c8a, 0x4c5b, 0x4c82, 0x4c32, + 0x4c24, 0x4c78, 0x4c31, 0x4c25, 0x4bd2, 0x4bda, 0x4a9c, 0x4c86, 0x4c31, 0x4bff, 0x4b04, 0x4c67, + 0x4c95, 0x4c19, 0x4a5e, 0x4c19, 0x4c78, 0x4c5f, 0x4c04, 0x4caf, 0x4c45, 0x4c14, 0x4c1a, 0x4b21, + 0x4c73, 0x4c86, 0x4c46, 0x4bc8, 0x4c13, 0x4b38, 0x4c0e, 0x4c11, 0x4cac, 0x4c65, 0x4c6e, 0x4cba, + 0x4baa, 0x4c21, 0x4c3d, 0x4c44, 0x4bf7, 0x4b9f, 0x4c61, 0x4c22, 0x4c0e, 0x4c75, 0x4bf2, 0x4ba3, + 0x4be0, 0x4d13, 0x4b96, 0x4c9a, 0x4c37, 0x4bf3, 0x4cb8, 0x4af8, 0x4c3a, 0x4c5e, 0x4ca8, 0x4c96, + 0x4c85, 0x4c2b, 0x4c84, 0x4bcc, 0x4c09, 0x4c3f, 0x4b37, 0x4bb7, 0x4c06, 0x4c4b, 0x4bf4, 0x4c10, + 0x4c30, 0x4c7c, 0x4b24, 0x4c1b, 0x4c3f, 0x4c14, 0x4ab2, 0x4c21, 0x4c56, 0x4ccb, 0x4ae3, 0x4c9c, + 0x4c17, 0x4b89, 0x4c03, 0x4b60, 0x4cd6, 0x4c1b, 0x4cd3, 0x4b53, 0x4c59, 0x4bf4, 0x4bd0, 0x4c02, + 0x4cbe, 0x4c26, 0x4c43, 0x4c52, 0x4bbd, 0x4c20, 0x4c35, 0x4c3a, 0x4bdd, 0x4c10, 0x4c1d, 0x4c05, + 0x4c4d, 0x4c65, 0x4c02, 0x4b60, 0x4b70, 0x4ccb, 0x4b99, 0x4c84, 0x4c55, 0x4bf0, 0x4cd1, 0x4b6e, + 0x4c36, 0x4c98, 0x4cd1, 0x4ca2, 0x4caf, 0x4c1b, 0x4c93, 0x4c15, 0x4b90, 0x4c4d, 0x4bd3, 0x4ba0, + 0x4af7, 0x4c1a, 0x4c25, 0x4c64, 0x4ba1, 0x4bbd, 0x4a6d, 0x4bca, 0x4c10, 0x4ae3, 0x4a3c, 0x4be1, + 0x4c01, 0x4c01, 0x4b31, 0x4c22, 0x4bda, 0x4bf4, 0x4b55, 0x4b1c, 0x4c7d, 0x4c36, 0x4c14, 0x4bdf, + 0x4c18, 0x4b00, 0x4b56, 0x4b4c, 0x4c64, 0x4b82, 0x4c5b, 0x4c37, 0x4ab0, 0x4b96, 0x4c0d, 0x4bbe, + 0x4b09, 0x4b1a, 0x4c19, 0x4c33, 0x4c30, 0x4c3e, 0x4af8, 0x4bad, 0x4c04, 0x4cb4, 0x4b43, 0x4c56, + 0x4c08, 0x4b1c, 0x4c2d, 0x4aa0, 0x4b64, 0x4c1f, 0x4ca0, 0x4c27, 0x4c58, 0x4c16, 0x4c76, 0x4abd, + 0x4b6a, 0x4c02, 0x4bcc, 0x4b68, 0x4af4, 0x4b98, 0x4b47, 0x4b65, 0x4c89, 0x4c99, 0x4aa0, 0x4c5c, + 0x4c74, 0x4bdc, 0x4ab4, 0x4c60, 0x4cc4, 0x4ca8, 0x4b8c, 0x4c58, 0x4c4e, 0x4bed, 0x4c08, 0x4b50, + 0x4cd1, 0x4c9a, 0x4ca3, 0x4c1b, 0x4c59, 0x4bc4, 0x4c27, 0x4c6f, 0x4ceb, 0x4c8a, 0x4c82, 0x4c8a, + 0x4c07, 0x4c54, 0x4c5f, 0x4ca5, 0x4c16, 0x4c37, 0x4c2e, 0x4c5e, 0x4c12, 0x4ca1, 0x4c19, 0x4c2d, + 0x4c49, 0x4d42, 0x4bb4, 0x4ca3, 0x4c68, 0x4c55, 0x4d6a, 0x4c0f, 0x4c6f, 0x4cea, 0x4cb9, 0x4c84, + 0x4cf1, 0x4c02, 0x4c48, 0x4bfb, 0x4c61, 0x4cad, 0x4c2c, 0x4b93, 0x4c03, 0x4b97, 0x4be0, 0x4c7d, + 0x4c35, 0x4c5c, 0x4b42, 0x4c27, 0x4c3b, 0x4c21, 0x4ac7, 0x4c5b, 0x4c92, 0x4c95, 0x4bb2, 0x4c6b, + 0x4c0c, 0x4c09, 0x4c16, 0x4b23, 0x4c8d, 0x4c8f, 0x4ccb, 0x4c0e, 0x4c79, 0x4be4, 0x4bc7, 0x4b8d, + 0x4cc3, 0x4cb3, 0x4c6d, 0x4cb6, 0x4bce, 0x4c23, 0x4c50, 0x4c81, 0x4c0a, 0x4c20, 0x4c2c, 0x4c62, + 0x4c0c, 0x4cbc, 0x4bb9, 0x4c01, 0x4c8c, 0x4d8b, 0x4be6, 0x4c82, 0x4c24, 0x4c13, 0x4ce8, 0x4c07, + 0x4cb6, 0x4c83, 0x4cb1, 0x4cc9, 0x4cc7, 0x4c0c, 0x4c69, 0x4c00, 0x4b96, 0x4c90, 0x4bd7, 0x4b79, + 0x4b48, 0x4c00, 0x4c1c, 0x4c77, 0x4c22, 0x4ca1, 0x4ac2, 0x4c1e, 0x4c9e, 0x4c4d, 0x4ab7, 0x4ca8, + 0x4cc3, 0x4c94, 0x4b20, 0x4ca2, 0x4c70, 0x4c10, 0x4bc6, 0x4b5a, 0x4c51, 0x4c0d, 0x4cfa, 0x4bfc, + 0x4ca2, 0x4c2c, 0x4c1b, 0x4c19, 0x4ce6, 0x4c79, 0x4c5e, 0x4ca2, 0x4ba6, 0x4c37, 0x4c14, 0x4c47, + 0x4bef, 0x4c0f, 0x4c86, 0x4c24, 0x4c2a, 0x4c98, 0x4c67, 0x4c38, 0x4c86, 0x4d14, 0x4c0b, 0x4cb1, + 0x4c43, 0x4c0d, 0x4cb7, 0x4b82, 0x4ca1, 0x4cf0, 0x4cf6, 0x4cda, 0x4c4e, 0x4c52, 0x4c59, 0x4bd4, + 0x4b67, 0x4caf, 0x4c1a, 0x4bc6, 0x4b81, 0x4bf0, 0x4c13, 0x4c94, 0x4c57, 0x4c5e, 0x4b6e, 0x4c39, + 0x4ce4, 0x4c7f, 0x4a88, 0x4c8b, 0x4c8a, 0x4cc3, 0x4bb6, 0x4c8c, 0x4c12, 0x4c8d, 0x4c50, 0x4b65, + 0x4cdd, 0x4c37, 0x4c9e, 0x4c0b, 0x4c00, 0x4c2f, 0x4c09, 0x4c2a, 0x4cd4, 0x4c8a, 0x4c63, 0x4c8f, + 0x4b83, 0x4c75, 0x4c3c, 0x4c59, 0x4c0b, 0x4ba5, 0x4c1a, 0x4c13, 0x4c2e, 0x4c9e, 0x4be3, 0x4c01, + 0x4c40, 0x4d02, 0x4bff, 0x4c7d, 0x4c02, 0x4bc3, 0x4cee, 0x4c26, 0x4c6c, 0x4cd1, 0x4d01, 0x4cbb, + 0x4cc7, 0x4c5a, 0x4c35, 0x4bfe, 0x4bb5, 0x4cb4, 0x4ba8, 0x4c0d, 0x4c4d, 0x4c0e, 0x4c50, 0x4c8b, + 0x4c3d, 0x4c91, 0x4bc1, 0x4c78, 0x4c57, 0x4c3c, 0x4a9d, 0x4c2d, 0x4ca4, 0x4cb8, 0x4ba5, 0x4c9e, + 0x4c09, 0x4bd9, 0x4be8, 0x4b62, 0x4cb9, 0x4c38, 0x4c9b, 0x4b79, 0x4c02, 0x4c30, 0x4c1b, 0x4c16, + 0x4cb0, 0x4cb9, 0x4c73, 0x4c56, 0x4b99, 0x4c36, 0x4c59, 0x4c55, 0x4bfe, 0x4c31, 0x4bc5, 0x4bc8, + 0x4c36, 0x4d03, 0x4bde, 0x4c31, 0x4c11, 0x4d70, 0x4bd1, 0x4c9c, 0x4c0e, 0x4c1a, 0x4cb9, 0x4c10, + 0x4c9c, 0x4cac, 0x4cff, 0x4c93, 0x4c93, 0x4c02, 0x4c63, 0x4c13, 0x4b69, 0x4c79, 0x4b96, 0x4b28, + 0x4bbe, 0x4c19, 0x4c4b, 0x4c72, 0x4c71, 0x4c8d, 0x4bca, 0x4c2c, 0x4cab, 0x4c27, 0x4b09, 0x4c4f, + 0x4c7b, 0x4ca2, 0x4b8f, 0x4c99, 0x4c12, 0x4c36, 0x4ba7, 0x4b2c, 0x4ced, 0x4c77, 0x4cf4, 0x4c0a, + 0x4c8f, 0x4bff, 0x4ba1, 0x4c1e, 0x4d34, 0x4c63, 0x4c5b, 0x4c5a, 0x4bda, 0x4c63, 0x4c3a, 0x4c9c, + 0x4c0c, 0x4c1e, 0x4c45, 0x4c7e, 0x4c5b, 0x4c99, 0x4c33, 0x4c28, 0x4c73, 0x4d44, 0x4bca, 0x4d0f, + 0x4c30, 0x4c0e, 0x4cf4, 0x4bfe, 0x4c7e, 0x4cab, 0x4d50, 0x4cb4, 0x4cc9, 0x4c4e, 0x4c8a, 0x4be7, + 0x4c18, 0x4c58, 0x4bef, 0x4bc0, 0x4b91, 0x4bfc, 0x4c1a, 0x4c97, 0x4a4c, 0x4b1e, 0x49ac, 0x4a9d, + 0x4ac0, 0x49de, 0x4912, 0x4a67, 0x4a86, 0x4ae6, 0x49e9, 0x4af4, 0x4a92, 0x4a4f, 0x49a9, 0x497f, + 0x4ace, 0x4a2c, 0x4b19, 0x4a6a, 0x4a9b, 0x4a0f, 0x499f, 0x4a23, 0x4b36, 0x4aef, 0x4b08, 0x4b5d, + 0x499b, 0x4b1d, 0x4a59, 0x4a08, 0x49a7, 0x4a3a, 0x4aa9, 0x49ea, 0x4af0, 0x4a9d, 0x49f4, 0x4a56, + 0x4b12, 0x4bf6, 0x4998, 0x4b6f, 0x49fa, 0x4a0e, 0x4aee, 0x4a23, 0x4a24, 0x4abd, 0x4af4, 0x4ab1, + 0x4ae5, 0x4a1b, 0x4af2, 0x49f5, 0x49f5, 0x4b01, 0x49e7, 0x49c2, 0x4a25, 0x4a3f, 0x4a0e, 0x4a9a, + 0x4c7f, 0x4ca9, 0x4c21, 0x4caa, 0x4cc2, 0x4c9c, 0x4a94, 0x4c97, 0x4d2a, 0x4d0c, 0x4c28, 0x4ce0, + 0x4cb5, 0x4c78, 0x4c8b, 0x4c3f, 0x4cf8, 0x4c7f, 0x4cf7, 0x4c70, 0x4c95, 0x4c7e, 0x4bd4, 0x4c28, + 0x4cd0, 0x4cbb, 0x4cab, 0x4cbb, 0x4c2e, 0x4c90, 0x4cba, 0x4cbb, 0x4c78, 0x4c3d, 0x4c79, 0x4c88, + 0x4c2f, 0x4d03, 0x4c46, 0x4c3b, 0x4ce5, 0x4dc2, 0x4b68, 0x4d26, 0x4c85, 0x4c88, 0x4ca8, 0x4c07, + 0x4cb7, 0x4cea, 0x4d6e, 0x4cd8, 0x4d0e, 0x4c94, 0x4cc3, 0x4c01, 0x4c56, 0x4d04, 0x4c5c, 0x4c7d, + 0x4c41, 0x4c4a, 0x4c55, 0x4c83, 0x4b1c, 0x4bca, 0x4aae, 0x4b89, 0x4c16, 0x4b2b, 0x4a4c, 0x4bba, + 0x4c0a, 0x4c27, 0x4b19, 0x4ba9, 0x4c22, 0x4bab, 0x4b78, 0x4a67, 0x4c24, 0x4b43, 0x4bc8, 0x4ba0, + 0x4c2d, 0x4afb, 0x4bc0, 0x4b63, 0x4c86, 0x4c1e, 0x4b4f, 0x4c00, 0x4a82, 0x4c10, 0x4bda, 0x4b72, + 0x4b3d, 0x4baf, 0x4b7e, 0x4b26, 0x4b7d, 0x4c46, 0x4b30, 0x4ab2, 0x4bb6, 0x4c96, 0x4b59, 0x4b5e, + 0x4b54, 0x4b1d, 0x4c21, 0x4a7f, 0x4bca, 0x4b7a, 0x4c68, 0x4c24, 0x4c25, 0x4b31, 0x4c15, 0x4b57, + 0x4ba9, 0x4b99, 0x4b38, 0x4bc8, 0x4ac9, 0x4b8e, 0x4af8, 0x4b66, 0x4b80, 0x4c39, 0x4af7, 0x4c2b, + 0x4c26, 0x4c32, 0x4a0e, 0x4b54, 0x4caf, 0x4c02, 0x4b23, 0x4c11, 0x4c24, 0x4b64, 0x4b85, 0x4ada, + 0x4c0a, 0x4b96, 0x4cc1, 0x4bdc, 0x4c30, 0x4c21, 0x4ba8, 0x4b33, 0x4c9b, 0x4bb0, 0x4c18, 0x4c05, + 0x4b4a, 0x4c1a, 0x4bdc, 0x4bb7, 0x4af3, 0x4b51, 0x4b62, 0x4c05, 0x4bc7, 0x4c34, 0x4c6c, 0x4b69, + 0x4c3b, 0x4ce5, 0x4bdc, 0x4c09, 0x4c40, 0x4b24, 0x4c92, 0x4a7f, 0x4c22, 0x4c63, 0x4c92, 0x4c62, + 0x4c9c, 0x4c0a, 0x4c14, 0x4b37, 0x4c04, 0x4c48, 0x4bd1, 0x4c0a, 0x4b6b, 0x4b2b, 0x4b84, 0x4c14, + 0x4c01, 0x4c59, 0x4b5a, 0x4c30, 0x4c48, 0x4c4b, 0x4a83, 0x4c7c, 0x4c98, 0x4c55, 0x4b92, 0x4cc2, + 0x4c94, 0x4bdb, 0x4be1, 0x4bd5, 0x4c82, 0x4c72, 0x4ccc, 0x4be1, 0x4c53, 0x4bb2, 0x4bef, 0x4b14, + 0x4cba, 0x4c57, 0x4c44, 0x4c97, 0x4b61, 0x4c21, 0x4c3b, 0x4c9d, 0x4bda, 0x4c24, 0x4c13, 0x4c6f, + 0x4c00, 0x4c99, 0x4c09, 0x4bcf, 0x4c41, 0x4d5c, 0x4bda, 0x4c3a, 0x4c0a, 0x4bc0, 0x4c91, 0x4b8b, + 0x4c39, 0x4c6e, 0x4d04, 0x4c7a, 0x4c91, 0x4c1a, 0x4c82, 0x4bbf, 0x4b87, 0x4ca8, 0x4b7d, 0x4ba3, + 0x4bb9, 0x4b72, 0x4c23, 0x4c59, 0x4c7f, 0x4cab, 0x4c53, 0x4cc4, 0x4d12, 0x4c6d, 0x4af5, 0x4c5a, + 0x4d28, 0x4d07, 0x4c26, 0x4cd4, 0x4c47, 0x4c4c, 0x4c5f, 0x4b69, 0x4d4d, 0x4c5b, 0x4d1e, 0x4c29, + 0x4c87, 0x4c3a, 0x4bfb, 0x4c39, 0x4d20, 0x4cc2, 0x4ca3, 0x4c7a, 0x4c1f, 0x4ce0, 0x4c85, 0x4cb0, + 0x4c1e, 0x4c68, 0x4c7e, 0x4c30, 0x4cb4, 0x4d23, 0x4c26, 0x4c82, 0x4cf1, 0x4db4, 0x4c44, 0x4d2f, + 0x4c39, 0x4c0a, 0x4d46, 0x4c0c, 0x4cc7, 0x4d12, 0x4d54, 0x4cf6, 0x4d24, 0x4c69, 0x4cdd, 0x4c64, + 0x4c0f, 0x4cad, 0x4c27, 0x4c58, 0x4c07, 0x4c51, 0x4c7f, 0x4d01, 0x4c7d, 0x4c0d, 0x4ad0, 0x4c77, + 0x4c8b, 0x4bfb, 0x4a84, 0x4c80, 0x4cad, 0x4c55, 0x4bad, 0x4cd2, 0x4c49, 0x4c57, 0x4bc6, 0x4b48, + 0x4ca5, 0x4c1f, 0x4cd2, 0x4c44, 0x4c4b, 0x4bd1, 0x4ba0, 0x4c43, 0x4ce2, 0x4c7e, 0x4c89, 0x4ca1, + 0x4b88, 0x4c5c, 0x4cac, 0x4c68, 0x4c14, 0x4be2, 0x4c47, 0x4c33, 0x4c2c, 0x4c6d, 0x4c52, 0x4c43, + 0x4c4e, 0x4d12, 0x4b6d, 0x4cdb, 0x4c40, 0x4c14, 0x4cf1, 0x4b4b, 0x4c63, 0x4cb5, 0x4cd1, 0x4d05, + 0x4c9e, 0x4c78, 0x4c66, 0x4c14, 0x4c29, 0x4c63, 0x4be1, 0x4c36, 0x4b2b, 0x4c52, 0x4ca2, 0x4ca6, + 0x4c9a, 0x4cc7, 0x4c36, 0x4cd8, 0x4d35, 0x4c67, 0x4a38, 0x4cde, 0x4d26, 0x4ca5, 0x4c0c, 0x4d5d, + 0x4caa, 0x4c8e, 0x4c7f, 0x4c8b, 0x4d45, 0x4d02, 0x4d52, 0x4c64, 0x4ccc, 0x4c2d, 0x4c2e, 0x4cdd, + 0x4d60, 0x4cfc, 0x4d14, 0x4cc9, 0x4c21, 0x4cdf, 0x4ca2, 0x4ca0, 0x4c2a, 0x4c6f, 0x4c85, 0x4cad, + 0x4c6a, 0x4d0f, 0x4c58, 0x4c7f, 0x4ca9, 0x4d8d, 0x4b51, 0x4d13, 0x4c67, 0x4cb8, 0x4d37, 0x4c38, + 0x4cb0, 0x4d15, 0x4d42, 0x4cd3, 0x4ce7, 0x4cc1, 0x4ce5, 0x4c4c, 0x4c74, 0x4d05, 0x4c48, 0x4c8f, + 0x4c59, 0x4ca6, 0x4cc0, 0x4cac, 0x4bd9, 0x4b7e, 0x4a67, 0x4b28, 0x4b8b, 0x4ba1, 0x49fc, 0x4ad3, + 0x4b8d, 0x4c0c, 0x4a84, 0x4c0f, 0x4b3c, 0x4bac, 0x4b55, 0x4a6a, 0x4c42, 0x4b5f, 0x4c3b, 0x4ac3, + 0x4b80, 0x4b0e, 0x4af9, 0x4b0f, 0x4b95, 0x4b7e, 0x4be9, 0x4bcc, 0x4b5d, 0x4b2b, 0x4b26, 0x4b6a, + 0x4b16, 0x4acb, 0x4ba4, 0x4b34, 0x4ae2, 0x4b9f, 0x4af8, 0x4b1d, 0x4acb, 0x4caa, 0x4a81, 0x4bbe, + 0x4b65, 0x4b81, 0x4c69, 0x4a79, 0x4bd7, 0x4c19, 0x4c41, 0x4b6e, 0x4bf7, 0x4bb1, 0x4bea, 0x4aca, + 0x4b60, 0x4be6, 0x4a71, 0x4b95, 0x4adc, 0x4b8e, 0x4afd, 0x4b94, 0x4c8d, 0x4c76, 0x4b15, 0x4c6b, + 0x4c99, 0x4c0f, 0x4a05, 0x4c3f, 0x4cab, 0x4cc3, 0x4bcf, 0x4c5c, 0x4c81, 0x4c52, 0x4c03, 0x4b4c, + 0x4d20, 0x4c68, 0x4c9a, 0x4c3c, 0x4c24, 0x4c14, 0x4b75, 0x4c5f, 0x4cd2, 0x4c97, 0x4c36, 0x4c60, + 0x4b85, 0x4c19, 0x4c1d, 0x4c7e, 0x4be7, 0x4c04, 0x4c58, 0x4c12, 0x4c0a, 0x4cbe, 0x4bd1, 0x4b95, + 0x4c74, 0x4d34, 0x4c02, 0x4ce6, 0x4be0, 0x4c41, 0x4cdb, 0x4b4f, 0x4c8e, 0x4c8d, 0x4d0a, 0x4cd4, + 0x4c64, 0x4c33, 0x4cba, 0x4c43, 0x4beb, 0x4c93, 0x4c1e, 0x4beb, 0x4be0, 0x4c40, 0x4baf, 0x4c6f, + 0x4b7f, 0x4b14, 0x4a7c, 0x4b88, 0x4bc6, 0x4b54, 0x4964, 0x4aeb, 0x4c1a, 0x4be7, 0x4a33, 0x4bc5, + 0x4b2b, 0x4b4a, 0x4af0, 0x4a55, 0x4be7, 0x4bd5, 0x4be6, 0x4c08, 0x4b08, 0x4a6b, 0x4a81, 0x4a71, + 0x4bff, 0x4ba8, 0x4b4e, 0x4b93, 0x4a17, 0x4ba2, 0x4baf, 0x4a90, 0x4b43, 0x4b04, 0x4b7e, 0x4ac7, + 0x4b2b, 0x4c15, 0x4ac3, 0x4b3d, 0x4b42, 0x4ca4, 0x49bc, 0x4b19, 0x4a5c, 0x4b46, 0x4c01, 0x4a9b, + 0x4b62, 0x4b55, 0x4c1a, 0x4b3b, 0x4c54, 0x4ae7, 0x4b00, 0x4a14, 0x4ac8, 0x4bb3, 0x4b08, 0x4ada, + 0x4a7b, 0x4ae5, 0x4b0c, 0x4b3f, 0x4cc5, 0x4c4c, 0x4b88, 0x4c0f, 0x4c9b, 0x4c2f, 0x4a72, 0x4c7a, + 0x4cb5, 0x4ccb, 0x4bd6, 0x4c8f, 0x4c35, 0x4c55, 0x4c32, 0x4b73, 0x4cca, 0x4c07, 0x4cb4, 0x4c16, + 0x4c5b, 0x4bef, 0x4c0f, 0x4c26, 0x4ca6, 0x4c82, 0x4c61, 0x4ca0, 0x4b9b, 0x4c59, 0x4c48, 0x4c75, + 0x4bbb, 0x4c5c, 0x4c37, 0x4c4d, 0x4c44, 0x4c86, 0x4c19, 0x4c21, 0x4c92, 0x4d75, 0x4b6b, 0x4cdc, + 0x4c13, 0x4c33, 0x4cd1, 0x4bfa, 0x4c50, 0x4cb2, 0x4d5d, 0x4ca9, 0x4cbb, 0x4c4d, 0x4c9c, 0x4bed, + 0x4c1c, 0x4c31, 0x4c39, 0x4c30, 0x4bce, 0x4c04, 0x4c4a, 0x4c89, 0x4c59, 0x4c4b, 0x4b30, 0x4c87, + 0x4c90, 0x4c16, 0x4b3e, 0x4c06, 0x4c88, 0x4c59, 0x4bf7, 0x4c8e, 0x4c8f, 0x4c41, 0x4c25, 0x4ba7, + 0x4ce4, 0x4c7e, 0x4cb4, 0x4c07, 0x4c45, 0x4bbe, 0x4c24, 0x4c44, 0x4cb6, 0x4c49, 0x4cc1, 0x4cc7, + 0x4c12, 0x4c49, 0x4c50, 0x4c5d, 0x4c1a, 0x4c3c, 0x4c8c, 0x4c56, 0x4c31, 0x4cc1, 0x4c0e, 0x4c3b, + 0x4c2b, 0x4d2f, 0x4ba4, 0x4c89, 0x4c30, 0x4c2b, 0x4ceb, 0x4b50, 0x4c41, 0x4c9f, 0x4cd6, 0x4c9a, + 0x4c94, 0x4c72, 0x4d01, 0x4c1f, 0x4c15, 0x4c86, 0x4c04, 0x4c42, 0x4bca, 0x4c58, 0x4c52, 0x4ca6, + 0x4bad, 0x4c2f, 0x4a38, 0x4b63, 0x4c1b, 0x4b03, 0x4930, 0x4c25, 0x4c25, 0x4c46, 0x4b1f, 0x4b4c, + 0x4bce, 0x4b74, 0x4b65, 0x4b26, 0x4c24, 0x4bdf, 0x4c24, 0x4b99, 0x4bc4, 0x4b67, 0x4aff, 0x4b41, + 0x4c86, 0x4c37, 0x4bbb, 0x4bf2, 0x4aa3, 0x4b25, 0x4b24, 0x4be7, 0x4acd, 0x4af8, 0x4b17, 0x4b22, + 0x4b5a, 0x4c47, 0x4ab0, 0x4b10, 0x4bf6, 0x4c9b, 0x4ab1, 0x4c39, 0x4b19, 0x4b3c, 0x4b98, 0x4ad9, + 0x4c04, 0x4c11, 0x4c50, 0x4c2e, 0x4c2c, 0x4b7e, 0x4c11, 0x4af9, 0x4b45, 0x4c27, 0x4abe, 0x4b4a, + 0x4b35, 0x4b24, 0x4aa3, 0x4bf2, 0x4c30, 0x4c79, 0x4a55, 0x4c6b, 0x4c11, 0x4bf3, 0x4a9f, 0x4bfe, + 0x4c33, 0x4c58, 0x4bff, 0x4c10, 0x4c77, 0x4c28, 0x4ba0, 0x4ad7, 0x4c96, 0x4c78, 0x4cae, 0x4c03, + 0x4c27, 0x4c04, 0x4b94, 0x4c08, 0x4ccd, 0x4c80, 0x4c16, 0x4c43, 0x4b3c, 0x4bd6, 0x4bd5, 0x4c3d, + 0x4ba6, 0x4c09, 0x4c41, 0x4c57, 0x4ba5, 0x4c85, 0x4c1d, 0x4be7, 0x4c41, 0x4d0b, 0x4ba5, 0x4c52, + 0x4c0b, 0x4b6c, 0x4c64, 0x4b3a, 0x4c45, 0x4c4a, 0x4ca0, 0x4c68, 0x4c67, 0x4bc0, 0x4c7a, 0x4b4c, + 0x4bb4, 0x4c59, 0x4be0, 0x4c25, 0x4bb8, 0x4bbd, 0x4b7b, 0x4c35, 0x4c69, 0x4c2e, 0x4b2a, 0x4c14, + 0x4ce5, 0x4c4d, 0x4adb, 0x4c80, 0x4ccd, 0x4c9e, 0x4bc4, 0x4cc6, 0x4c57, 0x4c12, 0x4c23, 0x4b74, + 0x4ca7, 0x4c76, 0x4cc1, 0x4c47, 0x4c74, 0x4bbf, 0x4c15, 0x4c22, 0x4ced, 0x4c52, 0x4c7e, 0x4cde, + 0x4bf0, 0x4c82, 0x4c62, 0x4c93, 0x4c05, 0x4bf8, 0x4c6c, 0x4ca0, 0x4c5d, 0x4cb4, 0x4bed, 0x4c15, + 0x4cbc, 0x4d32, 0x4c0b, 0x4c85, 0x4c4e, 0x4bf7, 0x4cb3, 0x4b8c, 0x4c46, 0x4c5b, 0x4cea, 0x4ca2, + 0x4c97, 0x4c97, 0x4c9c, 0x4c03, 0x4bda, 0x4c94, 0x4c28, 0x4c2a, 0x4be1, 0x4bfd, 0x4c3d, 0x4c5d, + 0x4ba8, 0x4c7b, 0x4a76, 0x4bfa, 0x4c02, 0x4b0e, 0x4a09, 0x4ae7, 0x4c0e, 0x4bdc, 0x4b37, 0x4bb4, + 0x4c0c, 0x4b48, 0x4b2b, 0x4ad0, 0x4bd1, 0x4b9c, 0x4c3c, 0x4b17, 0x4ba1, 0x4b30, 0x4a92, 0x4aab, + 0x4c43, 0x4c15, 0x4c15, 0x4c1d, 0x4b18, 0x4c02, 0x4b05, 0x4b6f, 0x4b31, 0x4b0c, 0x4b52, 0x4b55, + 0x4b08, 0x4c13, 0x4bc7, 0x4b21, 0x4b98, 0x4c9d, 0x4afd, 0x4b6e, 0x4b99, 0x4ad8, 0x4be2, 0x4adb, + 0x4b58, 0x4bfa, 0x4c3c, 0x4be7, 0x4c2d, 0x4b53, 0x4bad, 0x4b3e, 0x4b3f, 0x4c44, 0x4a62, 0x4ad3, + 0x4ae2, 0x4b0e, 0x4b30, 0x4b7b, 0x4c75, 0x4ce3, 0x4b19, 0x4c95, 0x4c9f, 0x4c64, 0x4a1f, 0x4c26, + 0x4c83, 0x4cde, 0x4b9b, 0x4c76, 0x4c7b, 0x4c43, 0x4c3b, 0x4b8c, 0x4c85, 0x4c86, 0x4cb5, 0x4c17, + 0x4c57, 0x4bb5, 0x4c55, 0x4c1c, 0x4d16, 0x4cc4, 0x4c79, 0x4c90, 0x4b36, 0x4c2e, 0x4c4a, 0x4c46, + 0x4bb8, 0x4c1a, 0x4c5b, 0x4c4c, 0x4c49, 0x4c5b, 0x4c2a, 0x4c27, 0x4c82, 0x4d49, 0x4b56, 0x4c97, + 0x4c2d, 0x4c26, 0x4c8e, 0x4c09, 0x4c60, 0x4cb1, 0x4cfa, 0x4ca3, 0x4cb0, 0x4c2e, 0x4ccb, 0x4c1a, + 0x4c6d, 0x4cb0, 0x4c13, 0x4c83, 0x4c10, 0x4c39, 0x4c1b, 0x4c37, 0x4c0a, 0x4c6c, 0x4b56, 0x4c53, + 0x4c51, 0x4c1e, 0x49e4, 0x4c78, 0x4c73, 0x4c8a, 0x4ba3, 0x4ccd, 0x4c3f, 0x4ba0, 0x4b87, 0x4b8a, + 0x4c98, 0x4c23, 0x4cd9, 0x4c0b, 0x4c42, 0x4b68, 0x4b48, 0x4be4, 0x4ce7, 0x4c9a, 0x4c38, 0x4c42, + 0x4baf, 0x4c3a, 0x4bf1, 0x4c51, 0x4b86, 0x4bda, 0x4c8f, 0x4c27, 0x4c27, 0x4c57, 0x4c13, 0x4c0a, + 0x4c3d, 0x4d19, 0x4b44, 0x4d05, 0x4c5c, 0x4c18, 0x4c7e, 0x4b4c, 0x4c25, 0x4c75, 0x4cf6, 0x4cc5, + 0x4c9a, 0x4c4a, 0x4cb0, 0x4bc1, 0x4c14, 0x4c5f, 0x4b8f, 0x4c2d, 0x4c04, 0x4c4e, 0x4b8c, 0x4c0f, + 0x4c76, 0x4c53, 0x4b25, 0x4c28, 0x4c75, 0x4c1d, 0x4abd, 0x4c7a, 0x4c7e, 0x4cf3, 0x4b96, 0x4c53, + 0x4c44, 0x4c5f, 0x4c2b, 0x4b34, 0x4cf8, 0x4c6f, 0x4cec, 0x4c3a, 0x4c39, 0x4c50, 0x4ba4, 0x4c05, + 0x4cbf, 0x4c84, 0x4c34, 0x4c5d, 0x4ba4, 0x4c4e, 0x4c94, 0x4c5b, 0x4c04, 0x4bf0, 0x4c38, 0x4c36, + 0x4c36, 0x4cde, 0x4be9, 0x4bca, 0x4c42, 0x4d44, 0x4bad, 0x4cd9, 0x4c74, 0x4c0f, 0x4ca4, 0x4b5e, + 0x4c87, 0x4c42, 0x4cda, 0x4ca6, 0x4c91, 0x4c35, 0x4cb5, 0x4bbb, 0x4c04, 0x4c77, 0x4ba0, 0x4c27, + 0x4bc0, 0x4c54, 0x4c31, 0x4c5b, 0x4c30, 0x4bce, 0x4ae2, 0x4c33, 0x4c53, 0x4c23, 0x4a1b, 0x4bf2, + 0x4c5e, 0x4c1a, 0x4afc, 0x4c15, 0x4b22, 0x4c08, 0x4bbd, 0x4b54, 0x4c6f, 0x4c27, 0x4c7e, 0x4c03, + 0x4bd9, 0x4b56, 0x4b7a, 0x4b74, 0x4c62, 0x4c1f, 0x4b91, 0x4c17, 0x4ae5, 0x4bda, 0x4b7d, 0x4b35, + 0x4ae5, 0x4b12, 0x4bd5, 0x4c31, 0x4b9a, 0x4c54, 0x4be5, 0x4c09, 0x4c21, 0x4cc8, 0x4b6d, 0x4c57, + 0x4b1f, 0x4b41, 0x4c4d, 0x4af8, 0x4be6, 0x4c35, 0x4cb9, 0x4c4b, 0x4cb3, 0x4ba5, 0x4bfb, 0x4ae1, + 0x4b2a, 0x4c2f, 0x4b51, 0x4b95, 0x4ac3, 0x4ba8, 0x4c24, 0x4c1c, 0x4cd6, 0x4ccf, 0x4ba7, 0x4cc8, + 0x4cbd, 0x4c5f, 0x4bda, 0x4cde, 0x4cf4, 0x4d04, 0x4c01, 0x4c8b, 0x4c75, 0x4cb2, 0x4c2d, 0x4bc0, + 0x4cd8, 0x4c8f, 0x4d28, 0x4cd9, 0x4cd0, 0x4c97, 0x4c09, 0x4c6e, 0x4d1c, 0x4caa, 0x4cc1, 0x4d2f, + 0x4be9, 0x4c8a, 0x4d14, 0x4c7f, 0x4caf, 0x4c6b, 0x4c83, 0x4c67, 0x4c95, 0x4d25, 0x4c41, 0x4c65, + 0x4d1b, 0x4d9a, 0x4c50, 0x4d19, 0x4c81, 0x4c4d, 0x4d1d, 0x4c27, 0x4cde, 0x4ceb, 0x4d6b, 0x4cd0, + 0x4d2b, 0x4c4a, 0x4cae, 0x4c28, 0x4c4f, 0x4ca2, 0x4c5a, 0x4c6f, 0x4c60, 0x4c98, 0x4c24, 0x4ca0, + 0x4b49, 0x4c05, 0x4b1b, 0x4c51, 0x4c15, 0x4b75, 0x4a6a, 0x4c6d, 0x4c4c, 0x4c61, 0x4bee, 0x4c8a, + 0x4bd0, 0x4b75, 0x4bae, 0x4b4a, 0x4c6a, 0x4c30, 0x4c54, 0x4c08, 0x4c0b, 0x4bef, 0x4a91, 0x4c04, + 0x4c86, 0x4c79, 0x4c1d, 0x4c51, 0x4b68, 0x4bc7, 0x4bc7, 0x4c21, 0x4bf1, 0x4b9c, 0x4bb9, 0x4c0b, + 0x4ae9, 0x4cb9, 0x4b27, 0x4b8f, 0x4bc0, 0x4cb3, 0x4b7b, 0x4c48, 0x4bcf, 0x4c0c, 0x4c95, 0x4ab0, + 0x4b91, 0x4c4d, 0x4c87, 0x4caf, 0x4c0f, 0x4bac, 0x4c11, 0x4afd, 0x4b89, 0x4c3e, 0x4b20, 0x4ae6, + 0x4b35, 0x4b71, 0x4be8, 0x4c18, 0x4c1a, 0x4cd2, 0x4ba4, 0x4c99, 0x4c4e, 0x4c15, 0x4b33, 0x4c8e, + 0x4cd4, 0x4ca0, 0x4bda, 0x4d15, 0x4c59, 0x4bf2, 0x4c1b, 0x4b86, 0x4cf7, 0x4c6a, 0x4d03, 0x4c38, + 0x4c65, 0x4bb6, 0x4bd0, 0x4c40, 0x4cca, 0x4c85, 0x4c6b, 0x4d01, 0x4c09, 0x4c4e, 0x4c59, 0x4c82, + 0x4c49, 0x4c11, 0x4cad, 0x4c20, 0x4c14, 0x4cd7, 0x4c33, 0x4c50, 0x4c0e, 0x4d79, 0x4c1b, 0x4ce7, + 0x4c76, 0x4ccc, 0x4cf0, 0x4b68, 0x4c80, 0x4c7f, 0x4cf1, 0x4cca, 0x4caa, 0x4c21, 0x4cb1, 0x4b7c, + 0x4c28, 0x4c61, 0x4bd7, 0x4c56, 0x4c0f, 0x4c42, 0x4c94, 0x4ca6, 0x4b6d, 0x4b1a, 0x4990, 0x4ac2, + 0x4bdb, 0x4bea, 0x499a, 0x4b3e, 0x4b88, 0x4bb9, 0x4a19, 0x4ba8, 0x4b5e, 0x4adf, 0x4afd, 0x4a4f, + 0x4ba2, 0x4b64, 0x4b09, 0x4b50, 0x4b34, 0x4a4c, 0x4afd, 0x4a9d, 0x4c14, 0x4ad3, 0x4bda, 0x4b4a, + 0x4a3a, 0x4a78, 0x4b63, 0x4bab, 0x4b62, 0x4a75, 0x4aec, 0x4b91, 0x4abd, 0x4b69, 0x4a47, 0x4aa6, + 0x4b4b, 0x4c7f, 0x49eb, 0x4b5e, 0x4b0c, 0x4ac7, 0x4c42, 0x4a78, 0x4c0b, 0x4ba1, 0x4b57, 0x4b78, + 0x4c2a, 0x4b1f, 0x4b98, 0x4ab2, 0x4b7a, 0x4b0d, 0x4a3f, 0x4a9f, 0x4a48, 0x4a75, 0x4a82, 0x4af8, + 0x4b91, 0x4c2a, 0x4a64, 0x4bd8, 0x4c08, 0x4bbe, 0x4ab4, 0x4bd0, 0x4bbd, 0x4c6a, 0x4a67, 0x4be9, + 0x4b65, 0x4bc2, 0x4b5b, 0x4a23, 0x4c24, 0x4bf2, 0x4c60, 0x4bc9, 0x4bc0, 0x4b86, 0x4b15, 0x4b30, + 0x4ca2, 0x4c32, 0x4ba5, 0x4be0, 0x4b31, 0x4bf1, 0x4b86, 0x4bdd, 0x4be4, 0x4af9, 0x4b91, 0x4bc0, + 0x4b24, 0x4c56, 0x4adf, 0x4abe, 0x4be9, 0x4ca8, 0x4b88, 0x4c23, 0x4b9d, 0x4bd0, 0x4c1e, 0x4aa9, + 0x4bc0, 0x4c09, 0x4c90, 0x4c25, 0x4c08, 0x4bc6, 0x4bc9, 0x4b4f, 0x4b83, 0x4c23, 0x4a72, 0x4b55, + 0x4aea, 0x4ac6, 0x4b43, 0x4bb7, 0x4c43, 0x4c26, 0x4ada, 0x4c21, 0x4c97, 0x4b64, 0x4a4e, 0x4c18, + 0x4c3e, 0x4c53, 0x4b9c, 0x4c30, 0x4c1c, 0x4b24, 0x4b7f, 0x4afa, 0x4cc0, 0x4bba, 0x4c72, 0x4b76, + 0x4bb3, 0x4bd0, 0x4b63, 0x4c32, 0x4c95, 0x4c3f, 0x4c31, 0x4c41, 0x4b83, 0x4be3, 0x4bba, 0x4bff, + 0x4b8d, 0x4b41, 0x4b4c, 0x4b8c, 0x4b16, 0x4c74, 0x4c06, 0x4b8d, 0x4bcf, 0x4c81, 0x4b9d, 0x4c93, + 0x4bc9, 0x4c56, 0x4c7c, 0x4b5e, 0x4bbd, 0x4c98, 0x4cb7, 0x4c3b, 0x4c5e, 0x4ba5, 0x4be0, 0x4b54, + 0x4b8a, 0x4c85, 0x4b7c, 0x4b46, 0x4b94, 0x4ae4, 0x4b18, 0x4c27, 0x4b16, 0x4b8c, 0x4a3d, 0x4b88, + 0x4c1b, 0x4b0f, 0x4a04, 0x4abe, 0x4c23, 0x4ba3, 0x4a4a, 0x4b38, 0x4b73, 0x4aef, 0x4adf, 0x4a2d, + 0x4c1c, 0x4b44, 0x4bc8, 0x4b0b, 0x4b84, 0x4aef, 0x4b71, 0x4ad4, 0x4c11, 0x4b8b, 0x4ac7, 0x4afa, + 0x4a97, 0x4b84, 0x4be4, 0x4b82, 0x4b31, 0x4b42, 0x4a9e, 0x4b09, 0x4a65, 0x4be0, 0x4b05, 0x4adb, + 0x4bdd, 0x4c0e, 0x4a93, 0x4afd, 0x4a97, 0x4aec, 0x4bbb, 0x4a07, 0x4b17, 0x4ba0, 0x4bf7, 0x4bf1, + 0x4b74, 0x4a9e, 0x4b2d, 0x4a79, 0x4b54, 0x4b2d, 0x4a8f, 0x4baa, 0x4a98, 0x4a1e, 0x4b65, 0x4b36, + 0x4c55, 0x4c88, 0x4b65, 0x4c62, 0x4ccb, 0x4c38, 0x4b3e, 0x4c1a, 0x4c8f, 0x4cc3, 0x4c34, 0x4cbb, + 0x4c76, 0x4be2, 0x4c2c, 0x4bb6, 0x4cf6, 0x4c80, 0x4ccc, 0x4c01, 0x4c86, 0x4c10, 0x4c22, 0x4c10, + 0x4d00, 0x4c6e, 0x4c64, 0x4ca2, 0x4be9, 0x4c84, 0x4c3b, 0x4c53, 0x4c26, 0x4bfa, 0x4c62, 0x4c4b, + 0x4c6a, 0x4cda, 0x4c5e, 0x4c2d, 0x4c8c, 0x4d3e, 0x4c32, 0x4cc0, 0x4c1e, 0x4c0c, 0x4c8b, 0x4b12, + 0x4c35, 0x4c7a, 0x4d08, 0x4cb9, 0x4ced, 0x4c57, 0x4c9f, 0x4c2e, 0x4c18, 0x4c57, 0x4bb1, 0x4c67, + 0x4bc1, 0x4c65, 0x4c26, 0x4c31, 0x4c48, 0x4c26, 0x4ae0, 0x4c9f, 0x4c72, 0x4c17, 0x4a1a, 0x4c03, + 0x4c61, 0x4c7a, 0x4c00, 0x4cc2, 0x4c46, 0x4c0d, 0x4c38, 0x4b5b, 0x4cf5, 0x4c73, 0x4c8d, 0x4c3a, + 0x4c01, 0x4c06, 0x4c0b, 0x4c2c, 0x4c86, 0x4c6d, 0x4c8f, 0x4c8d, 0x4b68, 0x4c0e, 0x4c90, 0x4c42, + 0x4c0e, 0x4c17, 0x4c1b, 0x4c33, 0x4c06, 0x4cbb, 0x4b81, 0x4be9, 0x4c50, 0x4d1b, 0x4b81, 0x4c7e, + 0x4c07, 0x4c4a, 0x4cd6, 0x4ac0, 0x4c60, 0x4c67, 0x4ccd, 0x4c9a, 0x4cc5, 0x4c63, 0x4cb2, 0x4b77, + 0x4c30, 0x4c6f, 0x4bd4, 0x4c1e, 0x4b90, 0x4bf8, 0x4c3a, 0x4c54, 0x4c89, 0x4c5e, 0x4c01, 0x4c71, + 0x4c9e, 0x4c5c, 0x4afc, 0x4c5b, 0x4cc7, 0x4c91, 0x4c4c, 0x4cab, 0x4c5c, 0x4c40, 0x4c33, 0x4b58, + 0x4cdc, 0x4cc6, 0x4cd4, 0x4bd6, 0x4c71, 0x4c57, 0x4bc1, 0x4c63, 0x4d69, 0x4cc1, 0x4c4c, 0x4ca6, + 0x4bb5, 0x4c8f, 0x4cac, 0x4c57, 0x4c18, 0x4c1d, 0x4c8f, 0x4c27, 0x4c43, 0x4cf2, 0x4c47, 0x4c98, + 0x4c2e, 0x4d72, 0x4c39, 0x4c7b, 0x4c5e, 0x4c15, 0x4d19, 0x4b4a, 0x4ccf, 0x4cc7, 0x4d42, 0x4d20, + 0x4d0d, 0x4c31, 0x4cbe, 0x4c35, 0x4c34, 0x4c5e, 0x4b89, 0x4c1f, 0x4c26, 0x4c5b, 0x4ca6, 0x4c59}; + +#endif //_TEST_MM_OS_2_INCLUDE_GUARD_ \ No newline at end of file diff --git a/tests/magia/mesh/mm_os_mglib/src/test.c b/tests/magia/mesh/mm_os_mglib/src/test.c new file mode 100644 index 00000000..50cf9eda --- /dev/null +++ b/tests/magia/mesh/mm_os_mglib/src/test.c @@ -0,0 +1,352 @@ +// Copyright 2025-2026 ETH Zurich, University of Bologna and Fondazione Chips-IT. +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// Alberto Dequino + +#include +#include "test.h" + +#include "tile.h" +#include "mg_idma.h" +#include "mg_redmule.h" +#include "mg_event.h" + +#define N_ITERATIONS 1 +#define N_TIMESLOTS 8 +#define WAIT_MODE WFE + +/** + * This test aims to verify the functionality of MAGIA as a systolic array for matrix + * multiplications, following the output-static mechanism. It is a copy of the mm_os_2 + * test, but issues transfers/jobs through the mglib layer (mg_idma / mg_redmule / + * mg_event) instead of calling the hal/drivers API directly. + */ +int main(void) +{ + /** + * 0. Get the mesh-tile's hartid, mesh-tile coordinates and define its L1 base, + * also initialize the controllers for the idma and redmule. + */ + uint32_t hartid = get_hartid(); + + idma_config_t idma_cfg = {.hartid = hartid}; + idma_controller_t idma_ctrl = { + .base = NULL, + .cfg = &idma_cfg, + .api = &idma_api, + }; + + redmule_config_t redmule_cfg = {.hartid = hartid}; + redmule_controller_t redmule_ctrl = { + .base = NULL, + .cfg = &redmule_cfg, + .api = &redmule_api, + }; + + idma_init(&idma_ctrl); + redmule_init(&redmule_ctrl); + + eu_config_t eu_cfg = {.hartid = hartid}; + eu_controller_t eu_ctrl = { + .base = NULL, + .cfg = &eu_cfg, + .api = &eu_api, + }; + eu_init(&eu_ctrl); + eu_redmule_init(&eu_ctrl, 0); + eu_idma_init(&eu_ctrl, 0); + + uint32_t y_id = GET_Y_ID(hartid); + uint32_t x_id = GET_X_ID(hartid); + uint32_t l1_tile_base = get_l1_base(hartid); + + /** + * 1. Calculate the static output data-tile dimensions. + * If M and K are perfect multiples of the number of mesh-tiles in their respective axis, + * tile_h and tile_w will be the same for each mesh-tile. + * Otherwise, these dimensions will be smaller for the mesh-tiles closer to the right and lower + * border of the mesh. + */ + uint32_t tile_h_max = ((M_SIZE + MESH_Y_TILES - 1) / MESH_Y_TILES); + uint32_t tile_w_max = ((K_SIZE + MESH_X_TILES - 1) / MESH_X_TILES); + int32_t tile_h; + int32_t tile_w; + + if (((tile_h_max * y_id) + tile_h_max) > M_SIZE) { + tile_h = M_SIZE - (tile_h_max * y_id); + } else { + tile_h = tile_h_max; + } + + if (((tile_w_max * x_id) + tile_w_max) > N_SIZE) { + tile_w = N_SIZE - (tile_w_max * x_id); + } else { + tile_w = tile_w_max; + } + + if (tile_h < 1 || tile_w < 1) { + return 0; + } else { + // printf("ID:%d, Mesh-Tile-X:%d, Mesh-Tile-Y:%d, Data-Tile w: %d, Data-Tile h: %d\n", + // hartid, x_id, y_id, tile_w, tile_h); + } + + /** + * 1a. Set the t_size, how many timeslots we want to divide the temporal dimension into. + * The final L1 memory requirement will be: + * Input data-tile: (tile_h x t_size) * data_dim + * Weight data-tile: (t_size x tile_w) * data_dim + * Output data-tile: ((tile_h x tile_w) * data_dim) + */ + uint8_t timeslots = N_TIMESLOTS; + uint8_t t_size = N_SIZE / timeslots; + + /** + * 2. Use IDMA to transfer static output data-tile + */ + uint32_t len_y = tile_w * 2; + uint32_t std_y = K_SIZE * 2; + uint32_t reps_y = (uint32_t)tile_h; + uint32_t obi_addr_y = (l1_tile_base); + uint32_t axi_addr_y = + (uint32_t)y_inp + (y_id * K_SIZE * tile_h_max * 2) + (tile_w_max * x_id * 2); + // uint32_t axi_addr_y_out = (uint32_t) y_out + (y_id * K_SIZE * tile_h_max * 2) + (tile_w_max * + // x_id * 2); + + /** + * 2a. Initalize the IDMA transfer variables for input data-tile transfers. + */ + uint32_t len_x = (uint32_t)(t_size * 2); + uint32_t std_x = (uint32_t)(N_SIZE * 2); + uint32_t reps_x = (uint32_t)tile_h; + uint32_t obi_addr_x_0 = obi_addr_y + (tile_h * tile_w * 2); + uint32_t obi_addr_x_1 = obi_addr_x_0 + (t_size * tile_h * 2); + uint32_t axi_addr_x = (uint32_t)x_inp + (y_id * N_SIZE * tile_h_max * 2); + + /** + * 2b. Initalize the IDMA transfer variables for weight data-tile transfers. + */ + uint32_t len_w = (uint32_t)(tile_w * 2); + uint32_t std_w = (uint32_t)(K_SIZE * 2); + uint32_t reps_w = (uint32_t)t_size; + uint32_t obi_addr_w_0 = obi_addr_x_1 + (t_size * tile_h * 2); + uint32_t obi_addr_w_1 = obi_addr_w_0 + (t_size * tile_w * 2); + uint32_t axi_addr_w = (uint32_t)w_inp + (x_id * tile_w_max * 2); + + // printf("tile_h = %d, tile_w = %d, t_size = %d\n", tile_h, tile_w, t_size); + + volatile uint32_t input_pt; + volatile uint32_t weight_pt; + volatile uint32_t input_pt_next; + volatile uint32_t weight_pt_next; + + mg_event_t idma_evt_x, idma_evt_y, idma_evt_w; + mg_event_t redmule_evt_0, redmule_evt_1; + mg_event_t *redmule_evt_next, *redmule_evt_curr; + + /** + * TEST LOOP - REPEAT THE TEST N_ITERATION TIMES. + */ + for (uint8_t z = 0; z < N_ITERATIONS; z++) { + /** 3. Timestlot t-1 + * Load the static output tile + * And then the t0 weight and input tiles + */ + mg_idma_memcpy_2d(&idma_ctrl, + &eu_ctrl, + WAIT_MODE, + 0, + axi_addr_y, + obi_addr_y, + len_y, + std_y, + reps_y, + &idma_evt_y, + NULL); + + // printf("Recieved this data: %x, %x\n", *(volatile uint16_t*)(obi_addr_y), *(volatile + // uint16_t*)(obi_addr_y + 2)); + + mg_idma_memcpy_2d(&idma_ctrl, + &eu_ctrl, + WAIT_MODE, + 0, + axi_addr_x, + obi_addr_x_0, + len_x, + std_x, + reps_x, + &idma_evt_x, + NULL); + + mg_idma_memcpy_2d(&idma_ctrl, + &eu_ctrl, + WAIT_MODE, + 0, + axi_addr_w, + obi_addr_w_0, + len_w, + std_w, + reps_w, + &idma_evt_w, + NULL); + + mg_idma_wait(&eu_ctrl, 0, WAIT_MODE, &idma_evt_x); + mg_idma_wait(&eu_ctrl, 0, WAIT_MODE, &idma_evt_w); + mg_idma_wait(&eu_ctrl, 0, WAIT_MODE, &idma_evt_y); + + // enqueue first redmule job, without triggering + mg_redmule_gemm_enqueue(&redmule_ctrl, + &eu_ctrl, + WAIT_MODE, + obi_addr_x_0, + obi_addr_w_0, + obi_addr_y, + (uint16_t)tile_h, + (uint16_t)t_size, + (uint16_t)tile_w, + &redmule_evt_0, + NULL); + + // commit it to the hardware queue (its inputs are already loaded above); + // this unlocks the controller for the next enqueue and lets the i=0 start + // actually launch it. + mg_redmule_gemm_commit(&redmule_ctrl); + + /** + * 4. Cycle over the timeslots. + * For each timeslot, the mesh-tile will: + * a - Load the weight and input data-tile for the next timeslot (if there is one) + * b - Multiply and add + * Synchronization is not required. + * We parallelize the IDMA with Redmule. + */ + for (uint8_t i = 0; i < timeslots; i++) { + // printf("TIMESLOT %d\n", i); + /** + * 4a. Select the correct pointer for the current timeslot + */ + if (i % 2) { + input_pt = obi_addr_x_1; + input_pt_next = obi_addr_x_0; + weight_pt = obi_addr_w_1; + weight_pt_next = obi_addr_w_0; + redmule_evt_curr = &redmule_evt_1; + redmule_evt_next = &redmule_evt_0; + } else { + input_pt = obi_addr_x_0; + input_pt_next = obi_addr_x_1; + weight_pt = obi_addr_w_0; + weight_pt_next = obi_addr_w_1; + redmule_evt_curr = &redmule_evt_0; + redmule_evt_next = &redmule_evt_1; + } + /** + * 4. IDMA to load the input and weight data-tile for next timeslot (if there is one) + * Call redmule while loading the weight of the next timeslot. + */ + if (i < (timeslots - 1)) { + // trigger current timeslot job if not already started + mg_redmule_gemm_start(&redmule_ctrl); + + // DMA copy-in for next timeslot + mg_idma_memcpy_2d(&idma_ctrl, + &eu_ctrl, + WAIT_MODE, + 0, + axi_addr_x + (t_size * (i + 1) * 2), + input_pt_next, + len_x, + std_x, + reps_x, + &idma_evt_x, + NULL); + + // enqueue next timeslot job + // it is convenient to do this here because mg_idma_memcpy_2d currently has a + // depth=1 queue! + mg_redmule_gemm_enqueue(&redmule_ctrl, + &eu_ctrl, + WAIT_MODE, + input_pt_next, + weight_pt_next, + obi_addr_y, + (uint16_t)tile_h, + (uint16_t)t_size, + (uint16_t)tile_w, + redmule_evt_next, + NULL); + + // DMA copy-in for next timeslot + mg_idma_memcpy_2d(&idma_ctrl, + &eu_ctrl, + WAIT_MODE, + 0, + axi_addr_w + (t_size * K_SIZE * (i + 1) * 2), + weight_pt_next, + len_w, + std_w, + reps_w, + &idma_evt_w, + NULL); + + // wait for the next timeslot's inputs before commiting its job + mg_idma_wait(&eu_ctrl, 0, WAIT_MODE, &idma_evt_x); + mg_idma_wait(&eu_ctrl, 0, WAIT_MODE, &idma_evt_w); + + // commit & start next timeslot job to hardware queue + mg_redmule_gemm_commit_start(&redmule_ctrl); + + // wait for current timeslot redmule + mg_redmule_wait(&eu_ctrl, WAIT_MODE, redmule_evt_curr); + + } else { + mg_redmule_gemm_start(&redmule_ctrl); + mg_redmule_wait(&eu_ctrl, WAIT_MODE, redmule_evt_curr); + } + } + + /** + * 5. Store the output data-tile back to L2 + */ + mg_idma_memcpy_2d(&idma_ctrl, + &eu_ctrl, + WAIT_MODE, + 1, + axi_addr_y, + obi_addr_y, + len_y, + std_y, + reps_y, + &idma_evt_y, + NULL); + mg_idma_wait(&eu_ctrl, 1, WAIT_MODE, &idma_evt_y); + } + + /** + * 6. Check results + */ + uint32_t errors = 0; + uint16_t computed, expected, diff = 0; + for (int i = (y_id * tile_h_max); i < (y_id * tile_h_max + tile_h); i++) { + for (int j = (x_id * tile_w_max); j < (x_id * tile_w_max) + tile_w; j++) { + computed = *(volatile uint16_t *)(y_inp + (i * K_SIZE + j)); + expected = *(volatile uint16_t *)(z_out + (i * K_SIZE + j)); + diff = (computed > expected) ? (computed - expected) : (expected - computed); + if (diff > 0x0011) { +#if EVAL == 1 + printf("Error detected at coordinates[%d][%d]: Y=%x Z=%x\n", + i, + j, + *(volatile uint16_t *)(y_inp + (i * K_SIZE + j)), + *(volatile uint16_t *)(z_out + (i * K_SIZE + j))); +#endif + errors++; + } + } + } + printf("Number of errors: %d\n", errors); + + return errors; +}