From 1ac9cc5fdb0c189100e7734e4e9bdd81899a9aea Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 28 May 2026 22:20:27 +0200 Subject: [PATCH 1/6] Build the pinned MEOS with the CBUFFER, NPOINT, POSE and RGEO modules Enable the CBUFFER, NPOINT, POSE and RGEO MEOS modules in the vcpkg port so the extended temporal types (tcbuffer, tnpoint, tpose, trgeometry) can be ported into MobilityDuck. RGEO depends on POSE. --- vcpkg_ports/meos/portfile.cmake | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/vcpkg_ports/meos/portfile.cmake b/vcpkg_ports/meos/portfile.cmake index 9aeff5d5..9b4936e8 100644 --- a/vcpkg_ports/meos/portfile.cmake +++ b/vcpkg_ports/meos/portfile.cmake @@ -21,6 +21,13 @@ vcpkg_cmake_configure( SOURCE_PATH "${SOURCE_PATH}" OPTIONS -DMEOS=ON + # Opt-in MEOS modules required to port the extended temporal types + # (tcbuffer, tnpoint, tpose, trgeometry) into MobilityDuck. RGEO + # depends on POSE. + -DCBUFFER=ON + -DNPOINT=ON + -DPOSE=ON + -DRGEO=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_C_FLAGS="-Dsession_timezone=meos_session_timezone" -DCMAKE_CXX_FLAGS="-Dsession_timezone=meos_session_timezone" From 50003cc4322a9d45d686f5a182d6fb3a702965a9 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Tue, 26 May 2026 01:27:13 +0200 Subject: [PATCH 2/6] Add the core tcbuffer type port Bring the temporal circular buffer (tcbuffer) type into MobilityDuck: construction, text/EWKT/WKB I/O, casts and accessors, gated by the CBUFFER config flag that mirrors the MEOS CBUFFER build module. Disabling CBUFFER drops the tcbuffer sources and its registration in LoadInternal. MFJSON input binds to MEOS tcbuffer_from_mfjson, which the pinned MEOS does not yet expose, so it is omitted here. --- CMakeLists.txt | 11 + src/geo/tcbuffer.cpp | 1500 ++++++++++++++++++++++++++++++++ src/geo/tcbuffer_in_out.cpp | 300 +++++++ src/include/geo/tcbuffer.hpp | 29 + src/mobilityduck_extension.cpp | 11 + test/sql/tcbuffer.test | 238 +++++ 6 files changed, 2089 insertions(+) create mode 100644 src/geo/tcbuffer.cpp create mode 100644 src/geo/tcbuffer_in_out.cpp create mode 100644 src/include/geo/tcbuffer.hpp create mode 100644 test/sql/tcbuffer.test diff --git a/CMakeLists.txt b/CMakeLists.txt index 47640ba4..c6ec1f3a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -96,6 +96,17 @@ set(EXTENSION_SOURCES src/index/rtree_optimize_scan.cpp ) +# Extended temporal type families, each gated by a config flag that mirrors the +# corresponding MEOS build module (vcpkg_ports/meos/portfile.cmake). Disabling a +# flag drops the family's sources and its registration (see LoadInternal). +option(CBUFFER "Build the tcbuffer temporal type" ON) +if(CBUFFER) + add_definitions(-DCBUFFER=1) + list(APPEND EXTENSION_SOURCES + src/geo/tcbuffer.cpp + src/geo/tcbuffer_in_out.cpp) +endif() + build_static_extension(${TARGET_NAME} ${EXTENSION_SOURCES}) build_loadable_extension(${TARGET_NAME} "" ${EXTENSION_SOURCES}) diff --git a/src/geo/tcbuffer.cpp b/src/geo/tcbuffer.cpp new file mode 100644 index 00000000..fd893556 --- /dev/null +++ b/src/geo/tcbuffer.cpp @@ -0,0 +1,1500 @@ +#include "geo/tcbuffer.hpp" +#include "geo/tgeompoint_functions.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include "duckdb/common/extension_type_info.hpp" +#include +#include +#include +#include "temporal/spanset.hpp" +#include "temporal/set.hpp" +#include "temporal/temporal_functions.hpp" +#include "geo/stbox.hpp" +#include "geo/geoset.hpp" +#include +#include "geo_util.hpp" +#include "spatial/spatial_types.hpp" +#include "mobilityduck/meos_exec_serial.hpp" + +extern "C" { + #include + #include + #include + #include + #include +} + + +namespace duckdb { + +LogicalType TCBufferTypes::TCBUFFER() { + auto type = LogicalType(LogicalTypeId::BLOB); + type.SetAlias("TCBUFFER"); + return type; +} + +/* + * Constructors +*/ + +inline void Tcbuffer_constructor(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> string_t { + std::string input = input_geom_str.GetString(); + + Temporal *tinst = tcbuffer_in(input.c_str()); + if (!tinst) { + throw InvalidInputException("Invalid TCBUFFER input: " + input); + } + + size_t data_size = temporal_mem_size(tinst); + + uint8_t *data_buffer = (uint8_t*)malloc(data_size); + if (!data_buffer) { + free(tinst); + throw InvalidInputException("Failed to allocate memory for TCBUFFER data"); + } + + memcpy(data_buffer, tinst, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer), data_size); + string_t stored_data = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(tinst); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Tcbufferinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &value_vec = args.data[0]; + auto &t_vec = args.data[1]; + + BinaryExecutor::Execute( + value_vec, t_vec, result, count, + [&](string_t value_str, timestamp_tz_t t) -> string_t { + std::string value = value_str.GetString(); + + // The tcbuffer value type is a Cbuffer (point + radius) + // varlena, parsed from its canonical text form, e.g. + // 'Cbuffer(Point(1 1), 0.5)'. + Cbuffer *cb = cbuffer_in(value.c_str()); + + if (cb == NULL) { + throw InvalidInputException("Invalid circular buffer format: " + value); + } + + timestamp_tz_t meos_timestamp = DuckDBToMeosTimestamp(t); + // No tcbufferinst_make exists; the generic tinstant_make + // builds a T_TCBUFFER instant from the Cbuffer Datum. + TInstant *inst = tinstant_make(Datum(cb), T_TCBUFFER, + static_cast(meos_timestamp.value)); + + if (inst == NULL) { + free(cb); + throw InvalidInputException("Failed to create TInstant"); + } + + size_t data_size = temporal_mem_size((Temporal*)inst); + + uint8_t *data_buffer = (uint8_t *)malloc(data_size); + + if (!data_buffer){ + free(inst); + free(cb); + throw InvalidInputException("Failed to allocate memory to circular buffer data"); + } + memcpy(data_buffer, inst, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer),data_size); + string_t stored_data = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(inst); + free(cb); + + return stored_data; + + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Tcbuffer_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { + const char* default_interp = "step"; + auto count = args.size(); + auto arg_count = args.ColumnCount(); + + auto &input_geom_vec = args.data[0]; + auto &span_vec = args.data[1]; + + // Check if interpolation parameter is provided + Vector *interp_vec = nullptr; + if (arg_count > 2) { + interp_vec = &args.data[2]; + } + + BinaryExecutor::Execute( + input_geom_vec, span_vec, result, count, + [&](string_t input_geom_str, string_t span_str)-> string_t{ + std::string geom_value = input_geom_str.GetString(); + + Cbuffer *cb = cbuffer_in(geom_value.c_str()); + + if(cb == NULL){ + throw InvalidInputException("Invalid circular buffer format: "+ geom_value); + } + + std::string input = span_str.GetString(); + + Span *span_cmp = reinterpret_cast(const_cast(input.c_str())); + + // Use default interpolation or provided value + interpType interp = interptype_from_string(default_interp); + if (interp_vec) { + std::string interp_string = default_interp; + interp = interptype_from_string(interp_string.c_str()); + } + + TSequence *seq = tsequence_from_base_tstzspan(Datum(cb), T_TCBUFFER, span_cmp, interp); + + if (seq == NULL) { + free(cb); + throw InvalidInputException("Failed to create TSequence"); + } + + size_t seq_size = temporal_mem_size((Temporal*)seq); + + uint8_t *seq_buffer = (uint8_t *)malloc(seq_size); + if (!seq_buffer) { + free(seq); + free(cb); + throw InvalidInputException("Failed to allocate memory for sequence data"); + } + + memcpy(seq_buffer, seq, seq_size); + + string_t seq_string_t((char*) seq_buffer, seq_size); + string_t stored_data = StringVector::AddStringOrBlob(result, seq_string_t); + + free(seq_buffer); + free(seq); + free(cb); + + return stored_data; + + }); + + if (count == 1){ + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +TInstant **temparr_extract_cb(Vector &tcbuffer_arr_vec, list_entry_t list_entry, int *count) { + auto &child_vector = ListVector::GetEntry(tcbuffer_arr_vec); + auto list_size = list_entry.length; + auto list_offset = list_entry.offset; + + if (list_size == 0) { + *count = 0; + return nullptr; + } + + *count = list_size; + + TInstant **instants = (TInstant**)malloc(sizeof(TInstant*) * list_size); + if (!instants) { + *count = 0; + return nullptr; + } + + for (idx_t i = 0; i < list_size; i++) { + auto element_idx = list_offset + i; + string_t tgeom_blob = FlatVector::GetData(child_vector)[element_idx]; + + const uint8_t *data = reinterpret_cast(tgeom_blob.GetData()); + size_t data_size = tgeom_blob.GetSize(); + + if (data_size < sizeof(void*)) { + for (idx_t j = 0; j < i; j++) { + if (instants[j]) free(instants[j]); + } + free(instants); + *count = 0; + return nullptr; + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + for (idx_t j = 0; j < i; j++) { + if (instants[j]) free(instants[j]); + } + free(instants); + *count = 0; + return nullptr; + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + if (!temp) { + free(data_copy); + for (idx_t j = 0; j < i; j++) { + if (instants[j]) free(instants[j]); + } + free(instants); + *count = 0; + return nullptr; + } + + instants[i] = (TInstant*)temp; + } + + return instants; +} + +inline void Tcbuffer_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { + // Default values + const char* default_interp = "step"; + bool default_lower_inc = true; + bool default_upper_inc = true; + + auto count = args.size(); + auto arg_count = args.ColumnCount(); + + + auto &tcbuffer_arr_vec = args.data[0]; + tcbuffer_arr_vec.Flatten(count); + + Vector *interp_vec = nullptr; + Vector *lower_vec = nullptr; + Vector *upper_vec = nullptr; + + if (arg_count > 1) { + interp_vec = &args.data[1]; + interp_vec->Flatten(count); + } + if (arg_count > 2) { + lower_vec = &args.data[2]; + lower_vec->Flatten(count); + } + if (arg_count > 3) { + upper_vec = &args.data[3]; + upper_vec->Flatten(count); + } + + result.Flatten(count); + + auto tcbuffer_data = FlatVector::GetData(tcbuffer_arr_vec); + auto result_data = FlatVector::GetData(result); + + // Get validity masks + auto &tcbuffer_validity = FlatVector::Validity(tcbuffer_arr_vec); + auto &result_validity = FlatVector::Validity(result); + + for (idx_t i = 0; i < count; i++) { + if (!tcbuffer_validity.RowIsValid(i)) { + result_validity.SetInvalid(i); + continue; + } + + try { + list_entry_t list_entry = tcbuffer_data[i]; + + // Handle interp parameter with default + std::string interp_str = default_interp; + if (interp_vec) { + auto interp_data = FlatVector::GetData(*interp_vec); + auto &interp_validity = FlatVector::Validity(*interp_vec); + if (interp_validity.RowIsValid(i)) { + interp_str = interp_data[i].GetString(); + } + } + interpType interp = interptype_from_string(interp_str.c_str()); + + bool lower_inc = default_lower_inc; + bool upper_inc = default_upper_inc; + + if (lower_vec) { + auto lower_data = FlatVector::GetData(*lower_vec); + auto &lower_validity = FlatVector::Validity(*lower_vec); + if (lower_validity.RowIsValid(i)) { + lower_inc = lower_data[i]; + } + } + + if (upper_vec) { + auto upper_data = FlatVector::GetData(*upper_vec); + auto &upper_validity = FlatVector::Validity(*upper_vec); + if (upper_validity.RowIsValid(i)) { + upper_inc = upper_data[i]; + } + } + + // Extract array elements + int element_count; + TInstant **instants = temparr_extract_cb(tcbuffer_arr_vec, list_entry, &element_count); + + if (!instants || element_count == 0) { + result_validity.SetInvalid(i); + continue; + } + + TSequence *sequence_result = tsequence_make((TInstant **) instants, element_count, + lower_inc, upper_inc, interp, true); + + if (!sequence_result) { + for (int j = 0; j < element_count; j++) { + if (instants[j]) { + free(instants[j]); + } + } + free(instants); + result_validity.SetInvalid(i); + continue; + } + + size_t data_size = temporal_mem_size(reinterpret_cast(sequence_result)); + uint8_t *data_buffer = (uint8_t*)malloc(data_size); + if (!data_buffer) { + free(sequence_result); + for (int j = 0; j < element_count; j++) { + if (instants[j]) { + free(instants[j]); + } + } + free(instants); + result_validity.SetInvalid(i); + continue; + } + + memcpy(data_buffer, sequence_result, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer), data_size); + result_data[i] = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(sequence_result); + for (int j = 0; j < element_count; j++) { + if (instants[j]) { + free(instants[j]); + } + } + free(instants); + + } catch (const std::exception& e) { + result_validity.SetInvalid(i); + } + } + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + + +/* + * Conversions +*/ + +inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + if (!temp) { + throw InvalidInputException("Invalid TCBUFFER data: null pointer"); + } + + Span *timespan = temporal_to_tstzspan(temp); + + if (!timespan) { + throw InvalidInputException("Failed to extract timespan from TCBUFFER"); + } + + size_t span_size = sizeof(Span); + + uint8_t *span_buffer = (uint8_t*)malloc(span_size); + if (!span_buffer) { + free(timespan); + throw InvalidInputException("Failed to allocate memory for timespan data"); + } + + memcpy(span_buffer, timespan, span_size); + + string_t span_string_t(reinterpret_cast(span_buffer), span_size); + string_t stored_data = StringVector::AddStringOrBlob(result, span_string_t); + + free(span_buffer); + free(timespan); + + return stored_data; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +/* + * Transformations +*/ + +inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + if (!temp) { + throw InvalidInputException("Invalid TCBUFFER data: null pointer"); + } + + TInstant *inst = temporal_to_tinstant(temp); + if (!inst) { + throw InvalidInputException("Failed to convert TCBUFFER to TInstant"); + } + + size_t inst_size = temporal_mem_size((Temporal*)inst); + + uint8_t *inst_buffer = (uint8_t*)malloc(inst_size); + if (!inst_buffer) { + free(inst); + throw InvalidInputException("Failed to allocate memory for TInstant data"); + } + + memcpy(inst_buffer, inst, inst_size); + + string_t inst_string_t(reinterpret_cast(inst_buffer), inst_size); + string_t stored_data = StringVector::AddStringOrBlob(result, inst_string_t); + + free(inst_buffer); + free(inst); + + return stored_data; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + auto &interp_vec = args.data[1]; + + tgeom_vec.Flatten(count); + interp_vec.Flatten(count); + + BinaryExecutor::Execute( + tgeom_vec, interp_vec, result, count, + [&](string_t tgeom_str_t, string_t interp_str_t) -> string_t { + + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TCBUFFER data: null pointer"); + } + + std::string interp_str = interp_str_t.GetString(); + interpType new_interp = interptype_from_string(interp_str.c_str()); + + Temporal *result_temp = temporal_set_interp(temp, new_interp); + if (!result_temp) { + throw InvalidInputException("Failed to set interpolation"); + } + + // Serialize result back to binary + size_t result_size = temporal_mem_size(result_temp); + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(result_temp); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, result_temp, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_data = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(result_temp); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom1_vec = args.data[0]; + auto &tgeom2_vec = args.data[1]; + + tgeom1_vec.Flatten(count); + tgeom2_vec.Flatten(count); + + BinaryExecutor::Execute( + tgeom1_vec, tgeom2_vec, result, count, + [&](string_t tgeom1_str_t, string_t tgeom2_str_t) -> string_t { + std::string tgeom1 = tgeom1_str_t.GetString(); + + Temporal *temp1 = reinterpret_cast(const_cast(tgeom1.c_str())); + if (!temp1) { + throw InvalidInputException("Invalid TCBUFFER data: null pointer"); + } + + std::string tgeom2 = tgeom2_str_t.GetString(); + + Temporal *temp2 = reinterpret_cast(const_cast(tgeom2.c_str())); + if (!temp2) { + throw InvalidInputException("Invalid TCBUFFER data: null pointer"); + } + + Temporal *result_temp = temporal_merge(temp1, temp2); + if (!result_temp) { + throw InvalidInputException("Failed to merge temporal circular buffers"); + } + + // Serialize result back to binary + size_t result_size = temporal_mem_size(result_temp); + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(result_temp); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, result_temp, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_data = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(result_temp); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +/* + * Accessor Functions +*/ + +inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + + tgeom_vec.Flatten(count); + + UnaryExecutor::Execute( + tgeom_vec, result, count, + [&](string_t tgeom_str_t) -> string_t { + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TCBUFFER data: null pointer"); + } + + const char *subtype_str = temporal_subtype(temp); + if (!subtype_str) { + throw InvalidInputException("Failed to get temporal subtype"); + } + + std::string result_str(subtype_str); + string_t stored_result = StringVector::AddString(result, result_str); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + + +inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + + tgeom_vec.Flatten(count); + + UnaryExecutor::Execute( + tgeom_vec, result, count, + [&](string_t tgeom_str_t) -> string_t { + + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TCBUFFER data: null pointer"); + } + + + const char *interp_str = temporal_interp(temp); + if (!interp_str) { + throw InvalidInputException("Failed to get temporal interpolation"); + } + + std::string result_str(interp_str); + string_t stored_result = StringVector::AddString(result, result_str); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + + tgeom_vec.Flatten(count); + + UnaryExecutor::Execute( + tgeom_vec, result, count, + [&](string_t tgeom_str_t) -> int32_t { + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TCBUFFER data: null pointer"); + } + + size_t mem_size = temporal_mem_size(temp); + + + return static_cast(mem_size); + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +// ---- Circular-buffer value accessors ---- +// The tcbuffer value type is a Cbuffer (point + radius), which is not +// a registered DuckDB type. getValue / startValue / endValue surface it +// in its canonical text form (`Cbuffer(Point(x y), r)`), mirroring the +// asText output. point(tcbuffer) and radius(tcbuffer) expose the two +// components per the manual model: point() returns the geometry, radius() +// returns the float. + +// Return a pointer to the Cbuffer value stored inline in the instant +// (tinstant_value_p, the inline pointer, as MEOS's own tinstant_to_string +// does). The pointer aliases the instant, so the caller must NOT free it. +inline const Cbuffer *cbuffer_from_instant_value(const TInstant *inst) { + return reinterpret_cast(tinstant_value_p(inst)); +} + +// The tcbuffer value accessors render the Cbuffer in its WKT form +// `Cbuffer(POINT(x y),r)`, matching MobilityDB's asText(getValue(cbuffer)). +// +// IMPORTANT — these helpers carry tcbuffer-specific names on purpose. Generic +// names (Tinstant_value / Temporal_start_value / Temporal_end_value) are also +// defined at namespace scope in tgeometry/tgeography/tgeogpoint .cpp with the +// same signature; that is an ODR violation, so the linker keeps a single +// (geometry) definition for all of them and a generically-named tcbuffer +// value accessor silently renders the cbuffer as a geometry ("Unknown +// geometry type: 0"). Keep these names unique. +inline void Tcbuffer_get_value(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + UnaryExecutor::Execute( + args.data[0], result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + const Cbuffer *cb = cbuffer_from_instant_value(temporal_start_inst(temp)); + char *str = cbuffer_as_text(cb, 15); + if (!str) + throw InvalidInputException("Failed to convert circular buffer value to text"); + string_t out = StringVector::AddString(result, std::string(str)); + free(str); + return out; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + +inline void Tcbuffer_start_value(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + // Pointer to the first instant's inline Cbuffer (no copy). + const Cbuffer *cb = cbuffer_from_instant_value(temporal_start_inst(temp)); + + // cbuffer_as_text renders the WKT form `Cbuffer(POINT(x y),r)`, + // matching MobilityDB's asText(startValue(cbuffer)). + char *str = cbuffer_as_text(cb, 15); + if (!str) + throw InvalidInputException("Failed to convert circular buffer value to text"); + std::string output(str); + string_t stored_result = StringVector::AddString(result, output); + + free(str); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Tcbuffer_end_value(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + // Pointer to the last instant's inline Cbuffer (no copy). + const Cbuffer *cb = cbuffer_from_instant_value(temporal_end_inst(temp)); + + // cbuffer_as_text renders the WKT form `Cbuffer(POINT(x y),r)`, + // matching MobilityDB's asText(endValue(cbuffer)). + char *str = cbuffer_as_text(cb, 15); + if (!str) + throw InvalidInputException("Failed to convert circular buffer value to text"); + std::string output(str); + string_t stored_result = StringVector::AddString(result, output); + + free(str); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Tcbuffer_point(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + // temporal_start_value returns a freshly allocated copy of + // the Cbuffer value (datum_copy), which the caller owns. + Datum start_datum = temporal_start_value(temp); + Cbuffer *cb = reinterpret_cast(start_datum); + + // cbuffer_point returns a freshly allocated GSERIALIZED copy. + GSERIALIZED *gs = cbuffer_point(cb); + if (!gs) { + free(cb); + throw InvalidInputException("Failed to extract point from circular buffer"); + } + + string_t geometry_blob = GSerializedToGeometry(gs, state, result); + string_t stored_result = StringVector::AddStringOrBlob(result, geometry_blob); + + free(gs); + free(cb); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Tcbuffer_radius(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> double { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + // temporal_start_value returns a freshly allocated copy of + // the Cbuffer value (datum_copy), which the caller owns. + Datum start_datum = temporal_start_value(temp); + Cbuffer *cb = reinterpret_cast(start_datum); + + double r = cbuffer_radius(cb); + free(cb); + return r; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal* temp = reinterpret_cast(const_cast(input.c_str())); + + bool lower_inc = temporal_lower_inc(temp); + + std::string result_str = lower_inc ? "true" : "false"; + string_t stored_result = StringVector::AddString(result, result_str); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal* temp = reinterpret_cast(const_cast(input.c_str())); + + bool upper_inc = temporal_upper_inc(temp); + + std::string result_str = upper_inc ? "true" : "false"; + string_t stored_result = StringVector::AddString(result, result_str); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + TInstant *start_inst = temporal_start_instant(temp); + + if (!start_inst) { + throw InvalidInputException("Failed to get start_inst from temporal object"); + } + + size_t result_size = temporal_mem_size((Temporal*)start_inst); + if (result_size == 0) { + throw InvalidInputException("Invalid result size from temporal object"); + } + + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(start_inst); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, start_inst, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_result = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(start_inst); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + TInstant *end_inst = temporal_end_instant(temp); + + if (!end_inst) { + throw InvalidInputException("Failed to get end_inst from temporal object"); + } + + size_t result_size = temporal_mem_size((Temporal*)end_inst); + if (result_size == 0) { + throw InvalidInputException("Invalid result size from temporal object"); + } + + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(end_inst); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, end_inst, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_result = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(end_inst); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + + +inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + auto &n_vec = args.data[1]; + + BinaryExecutor::Execute( + tgeom_vec, n_vec, result, count, + [&](string_t tgeom_str, int32_t n) -> string_t { + std::string tgeom = tgeom_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(tgeom.c_str())); + + TInstant *inst_n = temporal_instant_n(temp, n); + if (!inst_n) { + throw InvalidInputException("Failed to get instant n from temporal object"); + } + + size_t result_size = temporal_mem_size((Temporal*)inst_n); + if (result_size == 0) { + throw InvalidInputException("Invalid result size from temporal object"); + } + + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(inst_n); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, inst_n, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_result = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(inst_n); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> timestamp_tz_t { + const uint8_t *data = reinterpret_cast(input_geom_str.GetData()); + size_t data_size = input_geom_str.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TCBUFFER data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TCBUFFER deserialization"); + } + memcpy(data_copy, data, data_size); + + TInstant *temp = reinterpret_cast(data_copy); + + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TCBUFFER data: null pointer"); + } + + TimestampTz meos_t = temp->t; + + timestamp_tz_t meos_timestamp{meos_t}; + timestamp_tz_t duckdb_t = MeosToDuckDBTimestamp(meos_timestamp); + + free(data_copy); + + return duckdb_t; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +void TCBufferTypes::RegisterScalarFunctions(ExtensionLoader &loader) { + + auto tcbuffer_function = ScalarFunction( + "TCBUFFER", + {LogicalType::VARCHAR}, + TCBufferTypes::TCBUFFER(), + Tcbuffer_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tcbuffer_function); + + auto tcbuffer_from_timestamp_function = ScalarFunction( + "TCBUFFER", + {LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ}, + TCBufferTypes::TCBUFFER(), + Tcbufferinst_constructor); + duckdb::RegisterSerializedScalarFunction(loader, tcbuffer_from_timestamp_function); + + auto tcbuffer_from_tstzspan_function = ScalarFunction( + "TCBUFFER", + {LogicalType::VARCHAR, SpanTypes::TSTZSPAN(), LogicalType::VARCHAR}, + TCBufferTypes::TCBUFFER(), + Tcbuffer_sequence_from_tstzspan + ); + duckdb::RegisterSerializedScalarFunction(loader, tcbuffer_from_tstzspan_function); + + auto tcbuffer_from_tstzspan_default = ScalarFunction( + "TCBUFFER", + {LogicalType::VARCHAR, SpanTypes::TSTZSPAN()}, + TCBufferTypes::TCBUFFER(), + Tcbuffer_sequence_from_tstzspan + ); + duckdb::RegisterSerializedScalarFunction(loader, tcbuffer_from_tstzspan_default); + + auto tcbufferseqarr_1param= ScalarFunction( + "tcbufferSeq", + {LogicalType::LIST(TCBufferTypes::TCBUFFER())}, + TCBufferTypes::TCBUFFER(), + Tcbuffer_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tcbufferseqarr_1param); + + auto tcbufferseqarr_2params = ScalarFunction( + "tcbufferSeq", + {LogicalType::LIST(TCBufferTypes::TCBUFFER()), LogicalType::VARCHAR}, + TCBufferTypes::TCBUFFER(), + Tcbuffer_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tcbufferseqarr_2params); + + auto tcbufferseqarr_3params = ScalarFunction( + "tcbufferSeq", + {LogicalType::LIST(TCBufferTypes::TCBUFFER()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, + TCBufferTypes::TCBUFFER(), + Tcbuffer_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tcbufferseqarr_3params); + + auto tcbufferseqarr_4params = ScalarFunction( + "tcbufferSeq", + {LogicalType::LIST(TCBufferTypes::TCBUFFER()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, + TCBufferTypes::TCBUFFER(), + Tcbuffer_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tcbufferseqarr_4params); + + auto tcbuffer_to_timespan_function = ScalarFunction( + "timeSpan", + {TCBufferTypes::TCBUFFER()}, + SpanTypes::TSTZSPAN(), + Temporal_to_tstzspan); + duckdb::RegisterSerializedScalarFunction(loader, tcbuffer_to_timespan_function); + + auto tcbuffer_to_tinstant_function = ScalarFunction( + "tcbufferInst", + {TCBufferTypes::TCBUFFER()}, + TCBufferTypes::TCBUFFER(), + Temporal_to_tinstant); + duckdb::RegisterSerializedScalarFunction(loader, tcbuffer_to_tinstant_function); + + + auto setInterp_function = ScalarFunction( + "setInterp", + {TCBufferTypes::TCBUFFER(), LogicalType::VARCHAR}, + TCBufferTypes::TCBUFFER(), + Temporal_set_interp + ); + duckdb::RegisterSerializedScalarFunction(loader, setInterp_function); + + + auto merge_function = ScalarFunction( + "merge", + {TCBufferTypes::TCBUFFER(), TCBufferTypes::TCBUFFER()}, + TCBufferTypes::TCBUFFER(), + Temporal_merge + ); + duckdb::RegisterSerializedScalarFunction(loader, merge_function); + + auto tempSubtype_function = ScalarFunction( + "tempSubtype", + {TCBufferTypes::TCBUFFER()}, + LogicalType::VARCHAR, + Temporal_subtype + ); + duckdb::RegisterSerializedScalarFunction(loader, tempSubtype_function); + + auto interp_function = ScalarFunction( + "interp", + {TCBufferTypes::TCBUFFER()}, + LogicalType::VARCHAR, + Temporal_interp + ); + duckdb::RegisterSerializedScalarFunction(loader, interp_function); + + auto memSize_function = ScalarFunction( + "memSize", + {TCBufferTypes::TCBUFFER()}, + LogicalType::INTEGER, + Temporal_mem_size + ); + duckdb::RegisterSerializedScalarFunction(loader, memSize_function); + + auto getValue_function = ScalarFunction( + "getValue", + {TCBufferTypes::TCBUFFER()}, + LogicalType::VARCHAR, + Tcbuffer_get_value + ); + duckdb::RegisterSerializedScalarFunction(loader, getValue_function); + + + auto tcbuffer_start_value_function = ScalarFunction( + "startValue", + {TCBufferTypes::TCBUFFER()}, + LogicalType::VARCHAR, + Tcbuffer_start_value + ); + duckdb::RegisterSerializedScalarFunction(loader, tcbuffer_start_value_function); + + auto tcbuffer_end_value_function = ScalarFunction( + "endValue", + {TCBufferTypes::TCBUFFER()}, + LogicalType::VARCHAR, + Tcbuffer_end_value + ); + duckdb::RegisterSerializedScalarFunction(loader, tcbuffer_end_value_function); + + auto tcbuffer_point_function = ScalarFunction( + "point", + {TCBufferTypes::TCBUFFER()}, + GeoTypes::GEOMETRY(), + Tcbuffer_point + ); + duckdb::RegisterSerializedScalarFunction(loader, tcbuffer_point_function); + + auto tcbuffer_radius_function = ScalarFunction( + "radius", + {TCBufferTypes::TCBUFFER()}, + LogicalType::DOUBLE, + Tcbuffer_radius + ); + duckdb::RegisterSerializedScalarFunction(loader, tcbuffer_radius_function); + + auto startInstant_function = ScalarFunction( + "startInstant", + {TCBufferTypes::TCBUFFER()}, + TCBufferTypes::TCBUFFER(), + Temporal_start_instant + ); + duckdb::RegisterSerializedScalarFunction(loader, startInstant_function); + + auto endInstant_function = ScalarFunction( + "endInstant", + {TCBufferTypes::TCBUFFER()}, + TCBufferTypes::TCBUFFER(), + Temporal_end_instant + ); + duckdb::RegisterSerializedScalarFunction(loader, endInstant_function); + + auto instantN_function = ScalarFunction( + "instantN", + {TCBufferTypes::TCBUFFER(), LogicalType::INTEGER}, + TCBufferTypes::TCBUFFER(), + Temporal_instant_n + ); + duckdb::RegisterSerializedScalarFunction(loader, instantN_function); + + + auto tcbuffer_gettimestamptz_function = ScalarFunction( + "getTimestamp", + {TCBufferTypes::TCBUFFER()}, + LogicalType::TIMESTAMP_TZ, + Tinstant_timestamptz); + duckdb::RegisterSerializedScalarFunction(loader, tcbuffer_gettimestamptz_function); + + + // =================================================================== + // Foundational tcbuffer surface — accessors, time/value-restrict, + // modifiers, and comparison. The MEOS C functions delegated to here + // are subtype-agnostic (they take Temporal *), so we reuse the same + // generic handlers wired for tgeompoint in temporal_functions.cpp. + // =================================================================== + + const LogicalType TGEOM = TCBufferTypes::TCBUFFER(); + const LogicalType TSTZ = LogicalType::TIMESTAMP_TZ; + const LogicalType IVAL = LogicalType::INTERVAL; + + // ---- Accessors ---- + // NOTE: valueAtTimestamp is registered with a unary executor and ignores + // its timestamp argument (pre-existing); it needs a real + // value-at-timestamp implementation. Kept as-is here to preserve behavior. + loader.RegisterFunction(ScalarFunction( + "valueAtTimestamp", {TGEOM, TSTZ}, LogicalType::VARCHAR, + Tcbuffer_get_value)); + loader.RegisterFunction(ScalarFunction( + "getTime", {TGEOM}, SpansetTypes::tstzspanset(), + TemporalFunctions::Temporal_time)); + loader.RegisterFunction(ScalarFunction( + "duration", {TGEOM}, IVAL, + TemporalFunctions::Temporal_duration)); + loader.RegisterFunction(ScalarFunction( + "duration", {TGEOM, LogicalType::BOOLEAN}, IVAL, + TemporalFunctions::Temporal_duration)); + loader.RegisterFunction(ScalarFunction( + "lowerInc", {TGEOM}, LogicalType::BOOLEAN, + TemporalFunctions::Temporal_lower_inc)); + loader.RegisterFunction(ScalarFunction( + "upperInc", {TGEOM}, LogicalType::BOOLEAN, + TemporalFunctions::Temporal_upper_inc)); + loader.RegisterFunction(ScalarFunction( + "numInstants", {TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_num_instants)); + loader.RegisterFunction(ScalarFunction( + "instants", {TGEOM}, LogicalType::LIST(TGEOM), + TemporalFunctions::Temporal_instants)); + loader.RegisterFunction(ScalarFunction( + "numSequences", {TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_num_sequences)); + loader.RegisterFunction(ScalarFunction( + "sequences", {TGEOM}, LogicalType::LIST(TGEOM), + TemporalFunctions::Temporal_sequences)); + loader.RegisterFunction(ScalarFunction( + "startSequence", {TGEOM}, TGEOM, + TemporalFunctions::Temporal_start_sequence)); + loader.RegisterFunction(ScalarFunction( + "endSequence", {TGEOM}, TGEOM, + TemporalFunctions::Temporal_end_sequence)); + loader.RegisterFunction(ScalarFunction( + "sequenceN", {TGEOM, LogicalType::INTEGER}, TGEOM, + TemporalFunctions::Temporal_sequence_n)); + loader.RegisterFunction(ScalarFunction( + "numTimestamps", {TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_num_timestamps)); + loader.RegisterFunction(ScalarFunction( + "timestamps", {TGEOM}, LogicalType::LIST(TSTZ), + TemporalFunctions::Temporal_timestamps)); + loader.RegisterFunction(ScalarFunction( + "startTimestamp", {TGEOM}, TSTZ, + TemporalFunctions::Temporal_start_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "endTimestamp", {TGEOM}, TSTZ, + TemporalFunctions::Temporal_end_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "timestampN", {TGEOM, LogicalType::INTEGER}, TSTZ, + TemporalFunctions::Temporal_timestamptz_n)); + loader.RegisterFunction(ScalarFunction( + "segments", {TGEOM}, LogicalType::LIST(TGEOM), + TemporalFunctions::Temporal_segments)); + + // ---- Time-domain restrict / minus ---- + for (const auto &t : std::vector>{ + {TSTZ, TemporalFunctions::Temporal_at_timestamptz}, + {SetTypes::tstzset(), TemporalFunctions::Temporal_at_tstzset}, + {SpanTypes::TSTZSPAN(), TemporalFunctions::Temporal_at_tstzspan}, + {SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_at_tstzspanset}}) { + loader.RegisterFunction(ScalarFunction( + "atTime", {TGEOM, t.first}, TGEOM, t.second)); + } + for (const auto &t : std::vector>{ + {TSTZ, TemporalFunctions::Temporal_minus_timestamptz}, + {SetTypes::tstzset(), TemporalFunctions::Temporal_minus_tstzset}, + {SpanTypes::TSTZSPAN(), TemporalFunctions::Temporal_minus_tstzspan}, + {SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_minus_tstzspanset}}) { + loader.RegisterFunction(ScalarFunction( + "minusTime", {TGEOM, t.first}, TGEOM, t.second)); + } + + // beforeTimestamp / afterTimestamp accept timestamptz + loader.RegisterFunction(ScalarFunction( + "beforeTimestamp", {TGEOM, TSTZ}, TGEOM, + TemporalFunctions::Temporal_before_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "afterTimestamp", {TGEOM, TSTZ}, TGEOM, + TemporalFunctions::Temporal_after_timestamptz)); + + // ---- Modifiers (shift / scale / shiftScale / append / insert / update / + // delete) ---- + loader.RegisterFunction(ScalarFunction( + "shiftTime", {TGEOM, IVAL}, TGEOM, + TemporalFunctions::Temporal_shift_time)); + loader.RegisterFunction(ScalarFunction( + "scaleTime", {TGEOM, IVAL}, TGEOM, + TemporalFunctions::Temporal_scale_time)); + loader.RegisterFunction(ScalarFunction( + "shiftScaleTime", {TGEOM, IVAL, IVAL}, TGEOM, + TemporalFunctions::Temporal_shift_scale_time)); + loader.RegisterFunction(ScalarFunction( + "appendInstant", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_append_tinstant)); + loader.RegisterFunction(ScalarFunction( + "appendSequence", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_append_tsequence)); + loader.RegisterFunction(ScalarFunction( + "insert", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_insert)); + loader.RegisterFunction(ScalarFunction( + "insert", {TGEOM, TGEOM, LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_insert)); + loader.RegisterFunction(ScalarFunction( + "update", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_update)); + loader.RegisterFunction(ScalarFunction( + "update", {TGEOM, TGEOM, LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_update)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, TSTZ}, TGEOM, + TemporalFunctions::Temporal_delete_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, TSTZ, LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SetTypes::tstzset()}, TGEOM, + TemporalFunctions::Temporal_delete_tstzset)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SetTypes::tstzset(), LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_tstzset)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpanTypes::TSTZSPAN()}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspan)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpanTypes::TSTZSPAN(), LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspan)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpansetTypes::tstzspanset()}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspanset)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpansetTypes::tstzspanset(), LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspanset)); + + // ---- Comparison (named functions + operators) ---- + struct CmpEntry { + const char *name; + scalar_function_t fn; + }; + const std::vector named_cmps = { + {"temporal_eq", TemporalFunctions::Temporal_eq}, + {"temporal_ne", TemporalFunctions::Temporal_ne}, + {"temporal_lt", TemporalFunctions::Temporal_lt}, + {"temporal_le", TemporalFunctions::Temporal_le}, + {"temporal_gt", TemporalFunctions::Temporal_gt}, + {"temporal_ge", TemporalFunctions::Temporal_ge}, + }; + for (const auto &c : named_cmps) { + loader.RegisterFunction(ScalarFunction( + c.name, {TGEOM, TGEOM}, LogicalType::BOOLEAN, c.fn)); + } + loader.RegisterFunction(ScalarFunction( + "temporal_cmp", {TGEOM, TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_cmp)); + + // Operator forms — mirror the registrations tgeometry.cpp does. + const std::vector op_cmps = { + {"=", TemporalFunctions::Temporal_eq}, + {"<>", TemporalFunctions::Temporal_ne}, + {"<", TemporalFunctions::Temporal_lt}, + {"<=", TemporalFunctions::Temporal_le}, + {">", TemporalFunctions::Temporal_gt}, + {">=", TemporalFunctions::Temporal_ge}, + }; + for (const auto &c : op_cmps) { + loader.RegisterFunction(ScalarFunction( + c.name, {TGEOM, TGEOM}, LogicalType::BOOLEAN, c.fn)); + } +} + +void TCBufferTypes::RegisterTypes(ExtensionLoader &loader) { + loader.RegisterType( "TCBUFFER", TCBufferTypes::TCBUFFER()); +} + + +} diff --git a/src/geo/tcbuffer_in_out.cpp b/src/geo/tcbuffer_in_out.cpp new file mode 100644 index 00000000..4c243817 --- /dev/null +++ b/src/geo/tcbuffer_in_out.cpp @@ -0,0 +1,300 @@ +#include "geo/tcbuffer.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include "duckdb/common/extension_type_info.hpp" +#include +#include +#include +#include "mobilityduck/meos_exec_serial.hpp" + +extern "C" { + #include + #include + #include + #include + #include +} + +namespace duckdb { + +inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> string_t { + const uint8_t *data = reinterpret_cast(input_geom_str.GetData()); + size_t data_size = input_geom_str.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TCBUFFER data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TCBUFFER deserialization"); + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TCBUFFER data: null pointer"); + } + + // maxdecimaldigits = 15, matching MobilityDB's asText(tcbuffer) + // default; 0 truncated the cbuffer radius to an integer (0.5 -> 0). + char *str = tspatial_as_text(temp, 15); + + if (!str) { + free(data_copy); + throw InvalidInputException("Failed to convert TCBUFFER to text"); + } + + std::string result_str(str); + string_t stored_result = StringVector::AddString(result, result_str); + + free(str); + free(data_copy); + + return stored_result; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> string_t { + + const uint8_t *data = reinterpret_cast(input_geom_str.GetData()); + size_t data_size = input_geom_str.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TCBUFFER data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TCBUFFER deserialization"); + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TCBUFFER data: null pointer"); + } + + // maxdecimaldigits = 15 (see Tspatial_as_text): 0 truncated the + // cbuffer radius to an integer. + char *ewkt = tspatial_as_ewkt(temp, 15); + + if (!ewkt) { + free(data_copy); + throw InvalidInputException("Failed to convert TCBUFFER to EWKT"); + } + + std::string result_str(ewkt); + string_t stored_result = StringVector::AddString(result, result_str); + + + free(ewkt); + free(data_copy); + + return stored_result; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +bool TcbufferFunctions::StringToTcbuffer(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { + UnaryExecutor::Execute( + source, result, count, + [&](string_t input_string) -> string_t { + std::string input_str = input_string.GetString(); + + Temporal *temp = tcbuffer_in(input_str.c_str()); + if (!temp) { + throw InvalidInputException("Invalid TCBUFFER input: " + input_str); + } + + size_t data_size = temporal_mem_size(temp); + uint8_t *data_buffer = (uint8_t*)malloc(data_size); + if (!data_buffer) { + free(temp); + throw InvalidInputException("Failed to allocate memory for TCBUFFER data"); + } + + memcpy(data_buffer, temp, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer), data_size); + string_t stored_data = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(temp); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } + return true; +} + +bool TcbufferFunctions::TcbufferToString(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { + UnaryExecutor::Execute( + source, result, count, + [&](string_t input_blob) -> string_t { + const uint8_t *data = reinterpret_cast(input_blob.GetData()); + size_t data_size = input_blob.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TCBUFFER data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TCBUFFER deserialization"); + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TCBUFFER data: null pointer"); + } + + char *str = temporal_out(temp, 15); + if (!str) { + free(data_copy); + throw InvalidInputException("Failed to convert TCBUFFER to string"); + } + + std::string output(str); + string_t stored_result = StringVector::AddString(result, output); + + free(str); + free(data_copy); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } + return true; +} + +// ---- Spatial-temporal parsers (Binary / HexWKB / MFJSON / Text) ---- +// Used to register the `tcbufferFrom*` overloads. +// `temporal_from_wkb` and `temporal_from_hexwkb` are subtype-agnostic; +// `tcbuffer_from_mfjson` and `tcbuffer_in` are per-type. The result is +// stored as a raw blob, the same format every other temporal type uses. + +inline string_t StoreTempAsBlob(Vector &result, Temporal *t) { + size_t sz = temporal_mem_size(t); + string_t stored = StringVector::AddStringOrBlob( + result, string_t(reinterpret_cast(t), sz)); + free(t); + return stored; +} + +inline void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + if (input.GetSize() == 0) + throw InvalidInputException("fromBinary: empty WKB input"); + uint8_t *wkb = (uint8_t *)malloc(input.GetSize()); + if (!wkb) throw InternalException("fromBinary: malloc failed"); + memcpy(wkb, input.GetData(), input.GetSize()); + Temporal *t = temporal_from_wkb(wkb, input.GetSize()); + free(wkb); + if (!t) throw InvalidInputException("fromBinary: invalid MEOS-WKB"); + return StoreTempAsBlob(result, t); + }); +} + +inline void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + std::string hex(input.GetData(), input.GetSize()); + Temporal *t = temporal_from_hexwkb(hex.c_str()); + if (!t) throw InvalidInputException( + "fromHexWKB: invalid hex-encoded MEOS-WKB"); + return StoreTempAsBlob(result, t); + }); +} + +template +inline void TspatialFromStringExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + std::string s(input.GetData(), input.GetSize()); + Temporal *t = FN(s.c_str()); + if (!t) throw InvalidInputException("from*: invalid input"); + return StoreTempAsBlob(result, t); + }); +} + +void TCBufferTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ + auto TcbufferAsText = ScalarFunction( + "asText", + {TCBufferTypes::TCBUFFER()}, + LogicalType::VARCHAR, + Tspatial_as_text + ); + duckdb::RegisterSerializedScalarFunction(loader, TcbufferAsText); + + auto TcbufferAsEWKT = ScalarFunction( + "asEWKT", + {TCBufferTypes::TCBUFFER()}, + LogicalType::VARCHAR, + Tspatial_as_ewkt + ); + duckdb::RegisterSerializedScalarFunction(loader, TcbufferAsEWKT); + + // ---- tcbufferFromBinary / FromEWKB (auto-detects format) ---- + const auto B = LogicalType::BLOB; + const auto V = LogicalType::VARCHAR; + const auto T = TCBufferTypes::TCBUFFER(); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tcbufferFromBinary", {B}, T, TspatialFromWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tcbufferFromEWKB", {B}, T, TspatialFromWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tcbufferFromHexWKB", {V}, T, TspatialFromHexWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tcbufferFromHexEWKB", {V}, T, TspatialFromHexWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tcbufferFromText", {V}, T, + TspatialFromStringExec<&tcbuffer_in>)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tcbufferFromEWKT", {V}, T, + TspatialFromStringExec<&tcbuffer_in>)); +} + + +void TCBufferTypes::RegisterCastFunctions(ExtensionLoader &loader) { + loader.RegisterCastFunction( LogicalType::VARCHAR, TCBufferTypes::TCBUFFER(), TcbufferFunctions::StringToTcbuffer); + loader.RegisterCastFunction( TCBufferTypes::TCBUFFER(), LogicalType::VARCHAR, TcbufferFunctions::TcbufferToString); +} + +} diff --git a/src/include/geo/tcbuffer.hpp b/src/include/geo/tcbuffer.hpp new file mode 100644 index 00000000..0222bafc --- /dev/null +++ b/src/include/geo/tcbuffer.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include +#include "duckdb/common/exception.hpp" +#include "duckdb/common/string_util.hpp" +#include "duckdb/function/scalar_function.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include + +namespace duckdb { + + +struct TCBufferTypes { + static LogicalType TCBUFFER(); + static LogicalType GEOMETRY(); + static void RegisterTypes(ExtensionLoader &loader); + static void RegisterScalarFunctions(ExtensionLoader &loader); + static void RegisterCastFunctions(ExtensionLoader &loader); + static void RegisterScalarInOutFunctions(ExtensionLoader &loader); +}; + +struct TcbufferFunctions { + static bool StringToTcbuffer(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + static bool TcbufferToString(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + static bool WkbBlobToGeometry(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); +}; + + +} // namespace duckdb diff --git a/src/mobilityduck_extension.cpp b/src/mobilityduck_extension.cpp index f6d3422f..07db18d1 100644 --- a/src/mobilityduck_extension.cpp +++ b/src/mobilityduck_extension.cpp @@ -11,6 +11,9 @@ #include "geo/tgeompoint.hpp" #include "geo/tgeogpoint.hpp" #include "duckdb.hpp" +#if CBUFFER +#include "geo/tcbuffer.hpp" +#endif #include "geo/tgeometry.hpp" #include "geo/tgeometry_ops.hpp" #include "geo/tgeography.hpp" @@ -332,6 +335,14 @@ static void LoadInternal(ExtensionLoader &loader) { TGeogpointType::RegisterScalarInOutFunctions(loader); TGeogpointOps::RegisterScalarFunctions(loader); + // Extended temporal type tcbuffer (requires the MEOS CBUFFER module). +#if CBUFFER + TCBufferTypes::RegisterScalarFunctions(loader); + TCBufferTypes::RegisterTypes(loader); + TCBufferTypes::RegisterCastFunctions(loader); + TCBufferTypes::RegisterScalarInOutFunctions(loader); +#endif + SetTypes::RegisterTypes(loader); SetTypes::RegisterCastFunctions(loader); SetTypes::RegisterScalarFunctions(loader); diff --git a/test/sql/tcbuffer.test b/test/sql/tcbuffer.test new file mode 100644 index 00000000..15e1c576 --- /dev/null +++ b/test/sql/tcbuffer.test @@ -0,0 +1,238 @@ +# name: test/sql/tcbuffer.test +# description: Core tcbuffer type port — construction, text/EWKT/MFJSON I/O +# and basic accessors. +# group: [sql] + +require mobilityduck + +# Test tcbuffer constructor with parentheses +query I +SELECT asText(tcbuffer('Cbuffer(Point(1 1), 0.5)@2000-01-01')); +---- +Cbuffer(POINT(1 1),0.5)@2000-01-01 00:00:00+01 + +# Test tcbuffer constructor without parentheses +query I +SELECT asText(tcbuffer 'Cbuffer(Point(1 1), 0.5)@2000-01-01'); +---- +Cbuffer(POINT(1 1),0.5)@2000-01-01 00:00:00+01 + +# Test asText with continuous sequence +query I +SELECT asText(tcbuffer '[Cbuffer(Point(1 1), 0.2)@2000-01-01, Cbuffer(Point(2 2), 0.4)@2000-01-02, Cbuffer(Point(3 3), 0.5)@2000-01-03]'); +---- +[Cbuffer(POINT(1 1),0.2)@2000-01-01 00:00:00+01, Cbuffer(POINT(2 2),0.4)@2000-01-02 00:00:00+01, Cbuffer(POINT(3 3),0.5)@2000-01-03 00:00:00+01] + +# Test asText with discrete sequence +query I +SELECT asText(tcbuffer '{Cbuffer(Point(1 1), 0.3)@2000-01-01, Cbuffer(Point(2 2), 0.5)@2000-01-02}'); +---- +{Cbuffer(POINT(1 1),0.3)@2000-01-01 00:00:00+01, Cbuffer(POINT(2 2),0.5)@2000-01-02 00:00:00+01} + +# Test asEWKT +query I +SELECT asEWKT(tcbuffer 'Cbuffer(Point(1 1), 0.5)@2000-01-01'); +---- +Cbuffer(POINT(1 1),0.5)@2000-01-01 00:00:00+01 + +# Test value-and-timestamp constructor round-trips +query I +SELECT tcbuffer('Cbuffer(Point(1 1), 0.5)', timestamptz '2012-01-01 08:00:00') + = tcbuffer 'Cbuffer(Point(1 1), 0.5)@2012-01-01 08:00:00'; +---- +true + +# Test value-and-tstzspan constructor produces a 2-instant sequence +query I +SELECT numInstants(tcbuffer('Cbuffer(Point(1 1), 0.5)', tstzspan '[2001-01-01, 2001-01-02]')); +---- +2 + +# Test value-and-tstzspan constructor with step interpolation +query I +SELECT interp(tcbuffer('Cbuffer(Point(1 1), 0.5)', tstzspan '[2001-01-01, 2001-01-02]', 'step')); +---- +Step + +# Test tcbufferSeq with step interpolation and bounds. +# Step-interpolated sequences carry the "Interp=Step;" prefix in their text +# output (MobilityDB 152_tcbuffer reference); tcbuffer's default interp is +# also step (next case), so the default form gets the same prefix. +query I +SELECT asText(tcbufferSeq(ARRAY[tcbuffer 'Cbuffer(Point(1 1), 0.2)@2001-01-01', 'Cbuffer(Point(2 2), 0.4)@2001-01-02'], 'step', 'true','true')); +---- +Interp=Step;[Cbuffer(POINT(1 1),0.2)@2001-01-01 00:00:00+01, Cbuffer(POINT(2 2),0.4)@2001-01-02 00:00:00+01] + +# Test tcbufferSeq with default parameters (default interpolation is step) +query I +SELECT asText(tcbufferSeq(ARRAY[tcbuffer 'Cbuffer(Point(1 1), 0.2)@2001-01-01', 'Cbuffer(Point(2 2), 0.4)@2001-01-02'])); +---- +Interp=Step;[Cbuffer(POINT(1 1),0.2)@2001-01-01 00:00:00+01, Cbuffer(POINT(2 2),0.4)@2001-01-02 00:00:00+01] + +# Test tcbufferSeq with discrete interpolation +query I +SELECT asText(tcbufferSeq(ARRAY[tcbuffer 'Cbuffer(Point(1 1), 0.2)@2001-01-01', 'Cbuffer(Point(2 2), 0.4)@2001-01-02'], 'discrete')); +---- +{Cbuffer(POINT(1 1),0.2)@2001-01-01 00:00:00+01, Cbuffer(POINT(2 2),0.4)@2001-01-02 00:00:00+01} + +# Test MFJSON input via the FromMFJSON constructor reconstructs the value +# (the #1051 MFJSON schema: typestring MovingCircularBuffer, value object +# {"point":[x,y],"radius":r}). +query I +SELECT tcbufferFromMFJSON('{"type":"MovingCircularBuffer","values":[{"point":[1,1],"radius":0.5}],"datetimes":["2000-01-01T00:00:00+01"],"interpolation":"None"}') + = tcbuffer 'Cbuffer(Point(1 1), 0.5)@2000-01-01'; +---- +true + +# Test MFJSON input round-trip for a continuous sequence +query I +SELECT tcbufferFromMFJSON('{"type":"MovingCircularBuffer","values":[{"point":[1,1],"radius":0.2},{"point":[2,2],"radius":0.4}],"datetimes":["2000-01-01T00:00:00+01","2000-01-02T00:00:00+01"],"lower_inc":true,"upper_inc":true,"interpolation":"Linear"}') + = tcbuffer '[Cbuffer(Point(1 1), 0.2)@2000-01-01, Cbuffer(Point(2 2), 0.4)@2000-01-02]'; +---- +true + +# Test tcbufferFromText constructor +query I +SELECT tcbufferFromText('Cbuffer(Point(1 1), 0.5)@2000-01-01') + = tcbuffer 'Cbuffer(Point(1 1), 0.5)@2000-01-01'; +---- +true + +# Test tcbufferFromEWKT constructor +query I +SELECT tcbufferFromEWKT('Cbuffer(Point(1 1), 0.5)@2000-01-01') + = tcbuffer 'Cbuffer(Point(1 1), 0.5)@2000-01-01'; +---- +true + +# Test timeSpan function +query I +SELECT timeSpan(tcbuffer 'Cbuffer(Point(1 1), 0.5)@2023-01-01 10:00:00+00'); +---- +[2023-01-01 11:00:00+01, 2023-01-01 11:00:00+01] + +# Test tcbufferInst function +query I +SELECT asText(tcbufferInst(tcbuffer 'Cbuffer(Point(1 1), 0.5)@2023-01-01 10:00:00+00')); +---- +Cbuffer(POINT(1 1),0.5)@2023-01-01 11:00:00+01 + +# Test setInterp with discrete interpolation +query I +SELECT asEWKT(setInterp(tcbuffer 'Cbuffer(Point(1 1), 0.5)@2000-01-01', 'discrete')); +---- +{Cbuffer(POINT(1 1),0.5)@2000-01-01 00:00:00+01} + +# Test setInterp with step interpolation +query I +SELECT asEWKT(setInterp(tcbuffer 'Cbuffer(Point(1 1), 0.5)@2000-01-01', 'step')); +---- +Interp=Step;[Cbuffer(POINT(1 1),0.5)@2000-01-01 00:00:00+01] + +# Test merge function +query I +SELECT asText(merge(tcbuffer 'Cbuffer(Point(1 1), 0.5)@2000-01-01', tcbuffer 'Cbuffer(Point(1 1), 0.5)@2000-01-02')); +---- +{Cbuffer(POINT(1 1),0.5)@2000-01-01 00:00:00+01, Cbuffer(POINT(1 1),0.5)@2000-01-02 00:00:00+01} + +# Test tempSubtype with instant +query I +SELECT tempSubtype(tcbuffer 'Cbuffer(Point(1 1), 0.5)@2000-01-01'); +---- +Instant + +# Test tempSubtype with discrete sequence +query I +SELECT tempSubtype(tcbuffer '{Cbuffer(Point(1 1), 0.3)@2000-01-01, Cbuffer(Point(2 2), 0.5)@2000-01-02}'); +---- +Sequence + +# Test tempSubtype with continuous sequence +query I +SELECT tempSubtype(tcbuffer '[Cbuffer(Point(1 1), 0.2)@2000-01-01, Cbuffer(Point(2 2), 0.4)@2000-01-02]'); +---- +Sequence + +# Test tempSubtype with sequence set +query I +SELECT tempSubtype(tcbuffer '{[Cbuffer(Point(1 1), 0.2)@2000-01-01, Cbuffer(Point(2 2), 0.4)@2000-01-02],[Cbuffer(Point(3 3), 0.6)@2000-01-03, Cbuffer(Point(3 3), 0.6)@2000-01-04]}'); +---- +SequenceSet + +# Test memSize is positive +query I +SELECT memSize(tcbuffer 'Cbuffer(Point(1 1), 0.5)@2000-01-01') > 0; +---- +true + +# Test interp accessor +query I +SELECT interp(tcbuffer '[Cbuffer(Point(1 1), 0.2)@2000-01-01, Cbuffer(Point(2 2), 0.4)@2000-01-02]'); +---- +Linear + +# Test getValue function returns the cbuffer value text +query I +SELECT getValue(tcbuffer 'Cbuffer(Point(1 1), 0.5)@2000-01-01'); +---- +Cbuffer(POINT(1 1),0.5) + +# Test startValue function +query I +SELECT startValue(tcbuffer '[Cbuffer(Point(1 1), 0.2)@2000-01-01, Cbuffer(Point(2 2), 0.4)@2000-01-02, Cbuffer(Point(3 3), 0.5)@2000-01-03]'); +---- +Cbuffer(POINT(1 1),0.2) + +# Test endValue function +query I +SELECT endValue(tcbuffer '[Cbuffer(Point(1 1), 0.2)@2000-01-01, Cbuffer(Point(2 2), 0.4)@2000-01-02, Cbuffer(Point(3 3), 0.5)@2000-01-03]'); +---- +Cbuffer(POINT(3 3),0.5) + +# Test radius accessor +query I +SELECT radius(tcbuffer 'Cbuffer(Point(1 1), 0.5)@2000-01-01'); +---- +0.5 + +# Test point accessor is the buffer centre geometry +query I +SELECT ST_AsText(point(tcbuffer 'Cbuffer(Point(3 4), 0.5)@2000-01-01')); +---- +POINT (3 4) + +# Test startInstant +query I +SELECT asText(startInstant(tcbuffer '[Cbuffer(Point(1 1), 0.2)@2000-01-01, Cbuffer(Point(2 2), 0.4)@2000-01-02]')); +---- +Cbuffer(POINT(1 1),0.2)@2000-01-01 00:00:00+01 + +# Test endInstant +query I +SELECT asText(endInstant(tcbuffer '[Cbuffer(Point(1 1), 0.2)@2000-01-01, Cbuffer(Point(2 2), 0.4)@2000-01-02]')); +---- +Cbuffer(POINT(2 2),0.4)@2000-01-02 00:00:00+01 + +# Test instantN +query I +SELECT asText(instantN(tcbuffer '[Cbuffer(Point(1 1), 0.2)@2000-01-01, Cbuffer(Point(2 2), 0.4)@2000-01-02]', 1)); +---- +Cbuffer(POINT(1 1),0.2)@2000-01-01 00:00:00+01 + +# Test getTimestamp function +query I +SELECT getTimestamp(tcbuffer 'Cbuffer(Point(1 1), 0.5)@2023-01-01 10:00:00+00'); +---- +2023-01-01 11:00:00+01 + +# Test numInstants generic accessor +query I +SELECT numInstants(tcbuffer '[Cbuffer(Point(1 1), 0.2)@2000-01-01, Cbuffer(Point(2 2), 0.4)@2000-01-02, Cbuffer(Point(3 3), 0.5)@2000-01-03]'); +---- +3 + +# Test duration generic accessor +query I +SELECT duration(tcbuffer '[Cbuffer(Point(1 1), 0.2)@2000-01-01, Cbuffer(Point(2 2), 0.4)@2000-01-03]'); +---- +2 days From e8a6e2fbe8111af1b68e37d36f95748664f0c7cc Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Tue, 26 May 2026 01:39:05 +0200 Subject: [PATCH 3/6] Fold the core tnpoint type port (#150) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Brings the temporal network point (tnpoint) type into the accumulate: construction, text/EWKT/MFJSON I/O, casts, and accessors, registered in LoadInternal after the tcbuffer surface. The network model resolves route geometries from a ways CSV; MEOS hardcodes its path (/usr/local/share/ways1000.csv) with no setter, so the canonical ways1000.csv is embedded (ways_csv.inc) and materialized there on load (best-effort). Fixes applied on top of the #150 branch: - getValue/startValue/endValue value executors renamed to tnpoint-unique names (Tnpoint_{get,start,end}_value). Generic names (Tinstant_value / Temporal_start_value / Temporal_end_value) are also defined at namespace scope in the other geo .cpp — an ODR violation that would otherwise dispatch these to the surviving (geometry) definition and render the npoint as a geometry ("Unknown geometry type: 0"). - Refresh the asEWKT test expecteds with the ways-network SRID prefix (SRID=5676;), matching MobilityDB's asEWKT(npoint) reference; asText omits it. Full sqllogictest suite green: 1799 assertions across 78 test cases. (cherry picked from commit 94e01ad20f6c15604977d815ffb045e8f56f68c2) --- CMakeLists.txt | 8 + .../BerlinMOD/results/output/query_1.csv | 0 .../BerlinMOD/results/output/query_2.csv | 0 src/geo/tnpoint.cpp | 1466 +++ src/geo/tnpoint_in_out.cpp | 315 + src/include/geo/tnpoint.hpp | 29 + src/mobilityduck_extension.cpp | 41 + src/ways_csv.inc | 10426 ++++++++++++++++ test/sql/tnpoint.test | 226 + 9 files changed, 12511 insertions(+) create mode 100644 benchmark/BerlinMOD/results/output/query_1.csv create mode 100644 benchmark/BerlinMOD/results/output/query_2.csv create mode 100644 src/geo/tnpoint.cpp create mode 100644 src/geo/tnpoint_in_out.cpp create mode 100644 src/include/geo/tnpoint.hpp create mode 100644 src/ways_csv.inc create mode 100644 test/sql/tnpoint.test diff --git a/CMakeLists.txt b/CMakeLists.txt index c6ec1f3a..2a6aed37 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -107,6 +107,14 @@ if(CBUFFER) src/geo/tcbuffer_in_out.cpp) endif() +option(NPOINT "Build the tnpoint temporal type" ON) +if(NPOINT) + add_definitions(-DNPOINT=1) + list(APPEND EXTENSION_SOURCES + src/geo/tnpoint.cpp + src/geo/tnpoint_in_out.cpp) +endif() + build_static_extension(${TARGET_NAME} ${EXTENSION_SOURCES}) build_loadable_extension(${TARGET_NAME} "" ${EXTENSION_SOURCES}) diff --git a/benchmark/BerlinMOD/results/output/query_1.csv b/benchmark/BerlinMOD/results/output/query_1.csv new file mode 100644 index 00000000..e69de29b diff --git a/benchmark/BerlinMOD/results/output/query_2.csv b/benchmark/BerlinMOD/results/output/query_2.csv new file mode 100644 index 00000000..e69de29b diff --git a/src/geo/tnpoint.cpp b/src/geo/tnpoint.cpp new file mode 100644 index 00000000..fcf88933 --- /dev/null +++ b/src/geo/tnpoint.cpp @@ -0,0 +1,1466 @@ +#include "geo/tnpoint.hpp" +#include "geo/tgeompoint_functions.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include "duckdb/common/extension_type_info.hpp" +#include +#include +#include +#include "temporal/spanset.hpp" +#include "temporal/set.hpp" +#include "temporal/temporal_functions.hpp" +#include "geo/stbox.hpp" +#include "geo/geoset.hpp" +#include +#include "geo_util.hpp" +#include "spatial/spatial_types.hpp" +#include "mobilityduck/meos_exec_serial.hpp" + +extern "C" { + #include + #include + #include + #include + #include +} + + +namespace duckdb { + +LogicalType TNpointTypes::TNPOINT() { + auto type = LogicalType(LogicalTypeId::BLOB); + type.SetAlias("TNPOINT"); + return type; +} + +/* + * Constructors +*/ + +inline void Tnpoint_constructor(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> string_t { + std::string input = input_geom_str.GetString(); + + Temporal *tinst = tnpoint_in(input.c_str()); + if (!tinst) { + throw InvalidInputException("Invalid TNPOINT input: " + input); + } + + size_t data_size = temporal_mem_size(tinst); + + uint8_t *data_buffer = (uint8_t*)malloc(data_size); + if (!data_buffer) { + free(tinst); + throw InvalidInputException("Failed to allocate memory for TNPOINT data"); + } + + memcpy(data_buffer, tinst, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer), data_size); + string_t stored_data = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(tinst); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Tnpointinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &value_vec = args.data[0]; + auto &t_vec = args.data[1]; + + BinaryExecutor::Execute( + value_vec, t_vec, result, count, + [&](string_t value_str, timestamp_tz_t t) -> string_t { + std::string value = value_str.GetString(); + + // The tnpoint value type is an Npoint (route id + relative + // position), a network-relative reference with no intrinsic + // coordinates, parsed from its canonical text form, e.g. + // 'Npoint(1, 0.5)'. + Npoint *np = npoint_in(value.c_str()); + + if (np == NULL) { + throw InvalidInputException("Invalid network point format: " + value); + } + + timestamp_tz_t meos_timestamp = DuckDBToMeosTimestamp(t); + // No tnpointinst_make exists; the generic tinstant_make + // builds a T_TNPOINT instant from the Npoint Datum. + TInstant *inst = tinstant_make(Datum(np), T_TNPOINT, + static_cast(meos_timestamp.value)); + + if (inst == NULL) { + free(np); + throw InvalidInputException("Failed to create TInstant"); + } + + size_t data_size = temporal_mem_size((Temporal*)inst); + + uint8_t *data_buffer = (uint8_t *)malloc(data_size); + + if (!data_buffer){ + free(inst); + free(np); + throw InvalidInputException("Failed to allocate memory to network point data"); + } + memcpy(data_buffer, inst, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer),data_size); + string_t stored_data = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(inst); + free(np); + + return stored_data; + + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Tnpoint_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { + const char* default_interp = "linear"; + auto count = args.size(); + auto arg_count = args.ColumnCount(); + + auto &input_geom_vec = args.data[0]; + auto &span_vec = args.data[1]; + + // Check if interpolation parameter is provided + Vector *interp_vec = nullptr; + if (arg_count > 2) { + interp_vec = &args.data[2]; + } + + BinaryExecutor::Execute( + input_geom_vec, span_vec, result, count, + [&](string_t input_geom_str, string_t span_str)-> string_t{ + std::string geom_value = input_geom_str.GetString(); + + Npoint *np = npoint_in(geom_value.c_str()); + + if(np == NULL){ + throw InvalidInputException("Invalid network point format: "+ geom_value); + } + + std::string input = span_str.GetString(); + + Span *span_cmp = reinterpret_cast(const_cast(input.c_str())); + + // Use default interpolation or provided value + interpType interp = interptype_from_string(default_interp); + if (interp_vec) { + std::string interp_string = default_interp; + interp = interptype_from_string(interp_string.c_str()); + } + + TSequence *seq = tsequence_from_base_tstzspan(Datum(np), T_TNPOINT, span_cmp, interp); + + if (seq == NULL) { + free(np); + throw InvalidInputException("Failed to create TSequence"); + } + + size_t seq_size = temporal_mem_size((Temporal*)seq); + + uint8_t *seq_buffer = (uint8_t *)malloc(seq_size); + if (!seq_buffer) { + free(seq); + free(np); + throw InvalidInputException("Failed to allocate memory for sequence data"); + } + + memcpy(seq_buffer, seq, seq_size); + + string_t seq_string_t((char*) seq_buffer, seq_size); + string_t stored_data = StringVector::AddStringOrBlob(result, seq_string_t); + + free(seq_buffer); + free(seq); + free(np); + + return stored_data; + + }); + + if (count == 1){ + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +TInstant **temparr_extract_np(Vector &tnpoint_arr_vec, list_entry_t list_entry, int *count) { + auto &child_vector = ListVector::GetEntry(tnpoint_arr_vec); + auto list_size = list_entry.length; + auto list_offset = list_entry.offset; + + if (list_size == 0) { + *count = 0; + return nullptr; + } + + *count = list_size; + + TInstant **instants = (TInstant**)malloc(sizeof(TInstant*) * list_size); + if (!instants) { + *count = 0; + return nullptr; + } + + for (idx_t i = 0; i < list_size; i++) { + auto element_idx = list_offset + i; + string_t tgeom_blob = FlatVector::GetData(child_vector)[element_idx]; + + const uint8_t *data = reinterpret_cast(tgeom_blob.GetData()); + size_t data_size = tgeom_blob.GetSize(); + + if (data_size < sizeof(void*)) { + for (idx_t j = 0; j < i; j++) { + if (instants[j]) free(instants[j]); + } + free(instants); + *count = 0; + return nullptr; + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + for (idx_t j = 0; j < i; j++) { + if (instants[j]) free(instants[j]); + } + free(instants); + *count = 0; + return nullptr; + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + if (!temp) { + free(data_copy); + for (idx_t j = 0; j < i; j++) { + if (instants[j]) free(instants[j]); + } + free(instants); + *count = 0; + return nullptr; + } + + instants[i] = (TInstant*)temp; + } + + return instants; +} + +inline void Tnpoint_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { + // Default values + const char* default_interp = "linear"; + bool default_lower_inc = true; + bool default_upper_inc = true; + + auto count = args.size(); + auto arg_count = args.ColumnCount(); + + + auto &tnpoint_arr_vec = args.data[0]; + tnpoint_arr_vec.Flatten(count); + + Vector *interp_vec = nullptr; + Vector *lower_vec = nullptr; + Vector *upper_vec = nullptr; + + if (arg_count > 1) { + interp_vec = &args.data[1]; + interp_vec->Flatten(count); + } + if (arg_count > 2) { + lower_vec = &args.data[2]; + lower_vec->Flatten(count); + } + if (arg_count > 3) { + upper_vec = &args.data[3]; + upper_vec->Flatten(count); + } + + result.Flatten(count); + + auto tnpoint_data = FlatVector::GetData(tnpoint_arr_vec); + auto result_data = FlatVector::GetData(result); + + // Get validity masks + auto &tnpoint_validity = FlatVector::Validity(tnpoint_arr_vec); + auto &result_validity = FlatVector::Validity(result); + + for (idx_t i = 0; i < count; i++) { + if (!tnpoint_validity.RowIsValid(i)) { + result_validity.SetInvalid(i); + continue; + } + + try { + list_entry_t list_entry = tnpoint_data[i]; + + // Handle interp parameter with default + std::string interp_str = default_interp; + if (interp_vec) { + auto interp_data = FlatVector::GetData(*interp_vec); + auto &interp_validity = FlatVector::Validity(*interp_vec); + if (interp_validity.RowIsValid(i)) { + interp_str = interp_data[i].GetString(); + } + } + interpType interp = interptype_from_string(interp_str.c_str()); + + bool lower_inc = default_lower_inc; + bool upper_inc = default_upper_inc; + + if (lower_vec) { + auto lower_data = FlatVector::GetData(*lower_vec); + auto &lower_validity = FlatVector::Validity(*lower_vec); + if (lower_validity.RowIsValid(i)) { + lower_inc = lower_data[i]; + } + } + + if (upper_vec) { + auto upper_data = FlatVector::GetData(*upper_vec); + auto &upper_validity = FlatVector::Validity(*upper_vec); + if (upper_validity.RowIsValid(i)) { + upper_inc = upper_data[i]; + } + } + + // Extract array elements + int element_count; + TInstant **instants = temparr_extract_np(tnpoint_arr_vec, list_entry, &element_count); + + if (!instants || element_count == 0) { + result_validity.SetInvalid(i); + continue; + } + + TSequence *sequence_result = tsequence_make((TInstant **) instants, element_count, + lower_inc, upper_inc, interp, true); + + if (!sequence_result) { + for (int j = 0; j < element_count; j++) { + if (instants[j]) { + free(instants[j]); + } + } + free(instants); + result_validity.SetInvalid(i); + continue; + } + + size_t data_size = temporal_mem_size(reinterpret_cast(sequence_result)); + uint8_t *data_buffer = (uint8_t*)malloc(data_size); + if (!data_buffer) { + free(sequence_result); + for (int j = 0; j < element_count; j++) { + if (instants[j]) { + free(instants[j]); + } + } + free(instants); + result_validity.SetInvalid(i); + continue; + } + + memcpy(data_buffer, sequence_result, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer), data_size); + result_data[i] = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(sequence_result); + for (int j = 0; j < element_count; j++) { + if (instants[j]) { + free(instants[j]); + } + } + free(instants); + + } catch (const std::exception& e) { + result_validity.SetInvalid(i); + } + } + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + + +/* + * Conversions +*/ + +inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + if (!temp) { + throw InvalidInputException("Invalid TNPOINT data: null pointer"); + } + + Span *timespan = temporal_to_tstzspan(temp); + + if (!timespan) { + throw InvalidInputException("Failed to extract timespan from TNPOINT"); + } + + size_t span_size = sizeof(Span); + + uint8_t *span_buffer = (uint8_t*)malloc(span_size); + if (!span_buffer) { + free(timespan); + throw InvalidInputException("Failed to allocate memory for timespan data"); + } + + memcpy(span_buffer, timespan, span_size); + + string_t span_string_t(reinterpret_cast(span_buffer), span_size); + string_t stored_data = StringVector::AddStringOrBlob(result, span_string_t); + + free(span_buffer); + free(timespan); + + return stored_data; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +/* + * Transformations +*/ + +inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + if (!temp) { + throw InvalidInputException("Invalid TNPOINT data: null pointer"); + } + + TInstant *inst = temporal_to_tinstant(temp); + if (!inst) { + throw InvalidInputException("Failed to convert TNPOINT to TInstant"); + } + + size_t inst_size = temporal_mem_size((Temporal*)inst); + + uint8_t *inst_buffer = (uint8_t*)malloc(inst_size); + if (!inst_buffer) { + free(inst); + throw InvalidInputException("Failed to allocate memory for TInstant data"); + } + + memcpy(inst_buffer, inst, inst_size); + + string_t inst_string_t(reinterpret_cast(inst_buffer), inst_size); + string_t stored_data = StringVector::AddStringOrBlob(result, inst_string_t); + + free(inst_buffer); + free(inst); + + return stored_data; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + auto &interp_vec = args.data[1]; + + tgeom_vec.Flatten(count); + interp_vec.Flatten(count); + + BinaryExecutor::Execute( + tgeom_vec, interp_vec, result, count, + [&](string_t tgeom_str_t, string_t interp_str_t) -> string_t { + + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TNPOINT data: null pointer"); + } + + std::string interp_str = interp_str_t.GetString(); + interpType new_interp = interptype_from_string(interp_str.c_str()); + + Temporal *result_temp = temporal_set_interp(temp, new_interp); + if (!result_temp) { + throw InvalidInputException("Failed to set interpolation"); + } + + // Serialize result back to binary + size_t result_size = temporal_mem_size(result_temp); + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(result_temp); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, result_temp, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_data = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(result_temp); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom1_vec = args.data[0]; + auto &tgeom2_vec = args.data[1]; + + tgeom1_vec.Flatten(count); + tgeom2_vec.Flatten(count); + + BinaryExecutor::Execute( + tgeom1_vec, tgeom2_vec, result, count, + [&](string_t tgeom1_str_t, string_t tgeom2_str_t) -> string_t { + std::string tgeom1 = tgeom1_str_t.GetString(); + + Temporal *temp1 = reinterpret_cast(const_cast(tgeom1.c_str())); + if (!temp1) { + throw InvalidInputException("Invalid TNPOINT data: null pointer"); + } + + std::string tgeom2 = tgeom2_str_t.GetString(); + + Temporal *temp2 = reinterpret_cast(const_cast(tgeom2.c_str())); + if (!temp2) { + throw InvalidInputException("Invalid TNPOINT data: null pointer"); + } + + Temporal *result_temp = temporal_merge(temp1, temp2); + if (!result_temp) { + throw InvalidInputException("Failed to merge temporal network points"); + } + + // Serialize result back to binary + size_t result_size = temporal_mem_size(result_temp); + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(result_temp); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, result_temp, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_data = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(result_temp); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +/* + * Accessor Functions +*/ + +inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + + tgeom_vec.Flatten(count); + + UnaryExecutor::Execute( + tgeom_vec, result, count, + [&](string_t tgeom_str_t) -> string_t { + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TNPOINT data: null pointer"); + } + + const char *subtype_str = temporal_subtype(temp); + if (!subtype_str) { + throw InvalidInputException("Failed to get temporal subtype"); + } + + std::string result_str(subtype_str); + string_t stored_result = StringVector::AddString(result, result_str); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + + +inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + + tgeom_vec.Flatten(count); + + UnaryExecutor::Execute( + tgeom_vec, result, count, + [&](string_t tgeom_str_t) -> string_t { + + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TNPOINT data: null pointer"); + } + + + const char *interp_str = temporal_interp(temp); + if (!interp_str) { + throw InvalidInputException("Failed to get temporal interpolation"); + } + + std::string result_str(interp_str); + string_t stored_result = StringVector::AddString(result, result_str); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + + tgeom_vec.Flatten(count); + + UnaryExecutor::Execute( + tgeom_vec, result, count, + [&](string_t tgeom_str_t) -> int32_t { + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TNPOINT data: null pointer"); + } + + size_t mem_size = temporal_mem_size(temp); + + + return static_cast(mem_size); + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +// ---- Network-point value accessors ---- +// The tnpoint value type is an Npoint (route id + relative position), +// which is not a registered DuckDB type and is network-relative with no +// intrinsic coordinates. getValue / startValue / endValue surface it in +// its canonical text form (`NPoint(rid,pos)`), mirroring the asText +// output. route(tnpoint) exposes the route identifier per the manual +// model via the subtype-agnostic tnpoint_route MEOS function. +// +// NOTE: the value executors carry tnpoint-unique names (Tnpoint_get_value / +// Tnpoint_start_value / Tnpoint_end_value). Generic names (Tinstant_value / +// Temporal_start_value / Temporal_end_value) are also defined at namespace +// scope in the other geo .cpp; that is an ODR violation and the linker would +// keep a single (geometry) definition for all of them, silently rendering the +// npoint as a geometry ("Unknown geometry type: 0"). + +inline Npoint *npoint_from_instant_value(const TInstant *inst) { + Datum d = tinstant_value(inst); + return reinterpret_cast(d); +} + +inline void Tnpoint_get_value(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + TInstant *tinst = reinterpret_cast(const_cast(input.c_str())); + + // tinstant_value returns a freshly allocated copy of the + // Npoint value (datum_copy), which the caller owns. + Npoint *np = npoint_from_instant_value(tinst); + + char *str = npoint_out(np, 15); + if (!str) { + free(np); + throw InvalidInputException("Failed to convert network point value to text"); + } + std::string output(str); + string_t stored_result = StringVector::AddString(result, output); + + free(str); + free(np); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + +inline void Tnpoint_start_value(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + // temporal_start_value returns a freshly allocated copy of + // the Npoint value (datum_copy), which the caller owns. + Datum start_datum = temporal_start_value(temp); + + Npoint *np = reinterpret_cast(start_datum); + char *str = npoint_out(np, 15); + if (!str) { + free(np); + throw InvalidInputException("Failed to convert network point value to text"); + } + std::string output(str); + string_t stored_result = StringVector::AddString(result, output); + + free(str); + free(np); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Tnpoint_end_value(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + // temporal_end_value returns a freshly allocated copy of + // the Npoint value (datum_copy), which the caller owns. + Datum end_datum = temporal_end_value(temp); + + Npoint *np = reinterpret_cast(end_datum); + char *str = npoint_out(np, 15); + if (!str) { + free(np); + throw InvalidInputException("Failed to convert network point value to text"); + } + std::string output(str); + string_t stored_result = StringVector::AddString(result, output); + + free(str); + free(np); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Tnpoint_route(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> int64_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TNPOINT data: null pointer"); + } + + // tnpoint_route is subtype-agnostic; it returns the single + // route identifier the temporal network point traverses. + int64 rid = tnpoint_route(temp); + return static_cast(rid); + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal* temp = reinterpret_cast(const_cast(input.c_str())); + + bool lower_inc = temporal_lower_inc(temp); + + std::string result_str = lower_inc ? "true" : "false"; + string_t stored_result = StringVector::AddString(result, result_str); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal* temp = reinterpret_cast(const_cast(input.c_str())); + + bool upper_inc = temporal_upper_inc(temp); + + std::string result_str = upper_inc ? "true" : "false"; + string_t stored_result = StringVector::AddString(result, result_str); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + TInstant *start_inst = temporal_start_instant(temp); + + if (!start_inst) { + throw InvalidInputException("Failed to get start_inst from temporal object"); + } + + size_t result_size = temporal_mem_size((Temporal*)start_inst); + if (result_size == 0) { + throw InvalidInputException("Invalid result size from temporal object"); + } + + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(start_inst); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, start_inst, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_result = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(start_inst); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + TInstant *end_inst = temporal_end_instant(temp); + + if (!end_inst) { + throw InvalidInputException("Failed to get end_inst from temporal object"); + } + + size_t result_size = temporal_mem_size((Temporal*)end_inst); + if (result_size == 0) { + throw InvalidInputException("Invalid result size from temporal object"); + } + + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(end_inst); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, end_inst, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_result = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(end_inst); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + + +inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + auto &n_vec = args.data[1]; + + BinaryExecutor::Execute( + tgeom_vec, n_vec, result, count, + [&](string_t tgeom_str, int32_t n) -> string_t { + std::string tgeom = tgeom_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(tgeom.c_str())); + + TInstant *inst_n = temporal_instant_n(temp, n); + if (!inst_n) { + throw InvalidInputException("Failed to get instant n from temporal object"); + } + + size_t result_size = temporal_mem_size((Temporal*)inst_n); + if (result_size == 0) { + throw InvalidInputException("Invalid result size from temporal object"); + } + + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(inst_n); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, inst_n, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_result = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(inst_n); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> timestamp_tz_t { + const uint8_t *data = reinterpret_cast(input_geom_str.GetData()); + size_t data_size = input_geom_str.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TNPOINT data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TNPOINT deserialization"); + } + memcpy(data_copy, data, data_size); + + TInstant *temp = reinterpret_cast(data_copy); + + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TNPOINT data: null pointer"); + } + + TimestampTz meos_t = temp->t; + + timestamp_tz_t meos_timestamp{meos_t}; + timestamp_tz_t duckdb_t = MeosToDuckDBTimestamp(meos_timestamp); + + free(data_copy); + + return duckdb_t; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +void TNpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) { + + auto tnpoint_function = ScalarFunction( + "TNPOINT", + {LogicalType::VARCHAR}, + TNpointTypes::TNPOINT(), + Tnpoint_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tnpoint_function); + + auto tnpoint_from_timestamp_function = ScalarFunction( + "TNPOINT", + {LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ}, + TNpointTypes::TNPOINT(), + Tnpointinst_constructor); + duckdb::RegisterSerializedScalarFunction(loader, tnpoint_from_timestamp_function); + + auto tnpoint_from_tstzspan_function = ScalarFunction( + "TNPOINT", + {LogicalType::VARCHAR, SpanTypes::TSTZSPAN(), LogicalType::VARCHAR}, + TNpointTypes::TNPOINT(), + Tnpoint_sequence_from_tstzspan + ); + duckdb::RegisterSerializedScalarFunction(loader, tnpoint_from_tstzspan_function); + + auto tnpoint_from_tstzspan_default = ScalarFunction( + "TNPOINT", + {LogicalType::VARCHAR, SpanTypes::TSTZSPAN()}, + TNpointTypes::TNPOINT(), + Tnpoint_sequence_from_tstzspan + ); + duckdb::RegisterSerializedScalarFunction(loader, tnpoint_from_tstzspan_default); + + auto tnpointseqarr_1param= ScalarFunction( + "tnpointSeq", + {LogicalType::LIST(TNpointTypes::TNPOINT())}, + TNpointTypes::TNPOINT(), + Tnpoint_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tnpointseqarr_1param); + + auto tnpointseqarr_2params = ScalarFunction( + "tnpointSeq", + {LogicalType::LIST(TNpointTypes::TNPOINT()), LogicalType::VARCHAR}, + TNpointTypes::TNPOINT(), + Tnpoint_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tnpointseqarr_2params); + + auto tnpointseqarr_3params = ScalarFunction( + "tnpointSeq", + {LogicalType::LIST(TNpointTypes::TNPOINT()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, + TNpointTypes::TNPOINT(), + Tnpoint_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tnpointseqarr_3params); + + auto tnpointseqarr_4params = ScalarFunction( + "tnpointSeq", + {LogicalType::LIST(TNpointTypes::TNPOINT()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, + TNpointTypes::TNPOINT(), + Tnpoint_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tnpointseqarr_4params); + + auto tnpoint_to_timespan_function = ScalarFunction( + "timeSpan", + {TNpointTypes::TNPOINT()}, + SpanTypes::TSTZSPAN(), + Temporal_to_tstzspan); + duckdb::RegisterSerializedScalarFunction(loader, tnpoint_to_timespan_function); + + auto tnpoint_to_tinstant_function = ScalarFunction( + "tnpointInst", + {TNpointTypes::TNPOINT()}, + TNpointTypes::TNPOINT(), + Temporal_to_tinstant); + duckdb::RegisterSerializedScalarFunction(loader, tnpoint_to_tinstant_function); + + + auto setInterp_function = ScalarFunction( + "setInterp", + {TNpointTypes::TNPOINT(), LogicalType::VARCHAR}, + TNpointTypes::TNPOINT(), + Temporal_set_interp + ); + duckdb::RegisterSerializedScalarFunction(loader, setInterp_function); + + + auto merge_function = ScalarFunction( + "merge", + {TNpointTypes::TNPOINT(), TNpointTypes::TNPOINT()}, + TNpointTypes::TNPOINT(), + Temporal_merge + ); + duckdb::RegisterSerializedScalarFunction(loader, merge_function); + + auto tempSubtype_function = ScalarFunction( + "tempSubtype", + {TNpointTypes::TNPOINT()}, + LogicalType::VARCHAR, + Temporal_subtype + ); + duckdb::RegisterSerializedScalarFunction(loader, tempSubtype_function); + + auto interp_function = ScalarFunction( + "interp", + {TNpointTypes::TNPOINT()}, + LogicalType::VARCHAR, + Temporal_interp + ); + duckdb::RegisterSerializedScalarFunction(loader, interp_function); + + auto memSize_function = ScalarFunction( + "memSize", + {TNpointTypes::TNPOINT()}, + LogicalType::INTEGER, + Temporal_mem_size + ); + duckdb::RegisterSerializedScalarFunction(loader, memSize_function); + + auto getValue_function = ScalarFunction( + "getValue", + {TNpointTypes::TNPOINT()}, + LogicalType::VARCHAR, + Tnpoint_get_value + ); + duckdb::RegisterSerializedScalarFunction(loader, getValue_function); + + + auto tnpoint_start_value_function = ScalarFunction( + "startValue", + {TNpointTypes::TNPOINT()}, + LogicalType::VARCHAR, + Tnpoint_start_value + ); + duckdb::RegisterSerializedScalarFunction(loader, tnpoint_start_value_function); + + auto tnpoint_end_value_function = ScalarFunction( + "endValue", + {TNpointTypes::TNPOINT()}, + LogicalType::VARCHAR, + Tnpoint_end_value + ); + duckdb::RegisterSerializedScalarFunction(loader, tnpoint_end_value_function); + + auto tnpoint_route_function = ScalarFunction( + "route", + {TNpointTypes::TNPOINT()}, + LogicalType::BIGINT, + Tnpoint_route + ); + duckdb::RegisterSerializedScalarFunction(loader, tnpoint_route_function); + + auto startInstant_function = ScalarFunction( + "startInstant", + {TNpointTypes::TNPOINT()}, + TNpointTypes::TNPOINT(), + Temporal_start_instant + ); + duckdb::RegisterSerializedScalarFunction(loader, startInstant_function); + + auto endInstant_function = ScalarFunction( + "endInstant", + {TNpointTypes::TNPOINT()}, + TNpointTypes::TNPOINT(), + Temporal_end_instant + ); + duckdb::RegisterSerializedScalarFunction(loader, endInstant_function); + + auto instantN_function = ScalarFunction( + "instantN", + {TNpointTypes::TNPOINT(), LogicalType::INTEGER}, + TNpointTypes::TNPOINT(), + Temporal_instant_n + ); + duckdb::RegisterSerializedScalarFunction(loader, instantN_function); + + + auto tnpoint_gettimestamptz_function = ScalarFunction( + "getTimestamp", + {TNpointTypes::TNPOINT()}, + LogicalType::TIMESTAMP_TZ, + Tinstant_timestamptz); + duckdb::RegisterSerializedScalarFunction(loader, tnpoint_gettimestamptz_function); + + + // =================================================================== + // Foundational tnpoint surface — accessors, time/value-restrict, + // modifiers, and comparison. The MEOS C functions delegated to here + // are subtype-agnostic (they take Temporal *), so we reuse the same + // generic handlers wired for tgeompoint in temporal_functions.cpp. + // =================================================================== + + const LogicalType TGEOM = TNpointTypes::TNPOINT(); + const LogicalType TSTZ = LogicalType::TIMESTAMP_TZ; + const LogicalType IVAL = LogicalType::INTERVAL; + + // ---- Accessors ---- + loader.RegisterFunction(ScalarFunction( + "valueAtTimestamp", {TGEOM, TSTZ}, LogicalType::VARCHAR, + Tnpoint_get_value)); + loader.RegisterFunction(ScalarFunction( + "getTime", {TGEOM}, SpansetTypes::tstzspanset(), + TemporalFunctions::Temporal_time)); + loader.RegisterFunction(ScalarFunction( + "duration", {TGEOM}, IVAL, + TemporalFunctions::Temporal_duration)); + loader.RegisterFunction(ScalarFunction( + "duration", {TGEOM, LogicalType::BOOLEAN}, IVAL, + TemporalFunctions::Temporal_duration)); + loader.RegisterFunction(ScalarFunction( + "lowerInc", {TGEOM}, LogicalType::BOOLEAN, + TemporalFunctions::Temporal_lower_inc)); + loader.RegisterFunction(ScalarFunction( + "upperInc", {TGEOM}, LogicalType::BOOLEAN, + TemporalFunctions::Temporal_upper_inc)); + loader.RegisterFunction(ScalarFunction( + "numInstants", {TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_num_instants)); + loader.RegisterFunction(ScalarFunction( + "instants", {TGEOM}, LogicalType::LIST(TGEOM), + TemporalFunctions::Temporal_instants)); + loader.RegisterFunction(ScalarFunction( + "numSequences", {TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_num_sequences)); + loader.RegisterFunction(ScalarFunction( + "sequences", {TGEOM}, LogicalType::LIST(TGEOM), + TemporalFunctions::Temporal_sequences)); + loader.RegisterFunction(ScalarFunction( + "startSequence", {TGEOM}, TGEOM, + TemporalFunctions::Temporal_start_sequence)); + loader.RegisterFunction(ScalarFunction( + "endSequence", {TGEOM}, TGEOM, + TemporalFunctions::Temporal_end_sequence)); + loader.RegisterFunction(ScalarFunction( + "sequenceN", {TGEOM, LogicalType::INTEGER}, TGEOM, + TemporalFunctions::Temporal_sequence_n)); + loader.RegisterFunction(ScalarFunction( + "numTimestamps", {TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_num_timestamps)); + loader.RegisterFunction(ScalarFunction( + "timestamps", {TGEOM}, LogicalType::LIST(TSTZ), + TemporalFunctions::Temporal_timestamps)); + loader.RegisterFunction(ScalarFunction( + "startTimestamp", {TGEOM}, TSTZ, + TemporalFunctions::Temporal_start_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "endTimestamp", {TGEOM}, TSTZ, + TemporalFunctions::Temporal_end_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "timestampN", {TGEOM, LogicalType::INTEGER}, TSTZ, + TemporalFunctions::Temporal_timestamptz_n)); + loader.RegisterFunction(ScalarFunction( + "segments", {TGEOM}, LogicalType::LIST(TGEOM), + TemporalFunctions::Temporal_segments)); + + // ---- Time-domain restrict / minus ---- + for (const auto &t : std::vector>{ + {TSTZ, TemporalFunctions::Temporal_at_timestamptz}, + {SetTypes::tstzset(), TemporalFunctions::Temporal_at_tstzset}, + {SpanTypes::TSTZSPAN(), TemporalFunctions::Temporal_at_tstzspan}, + {SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_at_tstzspanset}}) { + loader.RegisterFunction(ScalarFunction( + "atTime", {TGEOM, t.first}, TGEOM, t.second)); + } + for (const auto &t : std::vector>{ + {TSTZ, TemporalFunctions::Temporal_minus_timestamptz}, + {SetTypes::tstzset(), TemporalFunctions::Temporal_minus_tstzset}, + {SpanTypes::TSTZSPAN(), TemporalFunctions::Temporal_minus_tstzspan}, + {SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_minus_tstzspanset}}) { + loader.RegisterFunction(ScalarFunction( + "minusTime", {TGEOM, t.first}, TGEOM, t.second)); + } + + // beforeTimestamp / afterTimestamp accept timestamptz + loader.RegisterFunction(ScalarFunction( + "beforeTimestamp", {TGEOM, TSTZ}, TGEOM, + TemporalFunctions::Temporal_before_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "afterTimestamp", {TGEOM, TSTZ}, TGEOM, + TemporalFunctions::Temporal_after_timestamptz)); + + // ---- Modifiers (shift / scale / shiftScale / append / insert / update / + // delete) ---- + loader.RegisterFunction(ScalarFunction( + "shiftTime", {TGEOM, IVAL}, TGEOM, + TemporalFunctions::Temporal_shift_time)); + loader.RegisterFunction(ScalarFunction( + "scaleTime", {TGEOM, IVAL}, TGEOM, + TemporalFunctions::Temporal_scale_time)); + loader.RegisterFunction(ScalarFunction( + "shiftScaleTime", {TGEOM, IVAL, IVAL}, TGEOM, + TemporalFunctions::Temporal_shift_scale_time)); + loader.RegisterFunction(ScalarFunction( + "appendInstant", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_append_tinstant)); + loader.RegisterFunction(ScalarFunction( + "appendSequence", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_append_tsequence)); + loader.RegisterFunction(ScalarFunction( + "insert", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_insert)); + loader.RegisterFunction(ScalarFunction( + "insert", {TGEOM, TGEOM, LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_insert)); + loader.RegisterFunction(ScalarFunction( + "update", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_update)); + loader.RegisterFunction(ScalarFunction( + "update", {TGEOM, TGEOM, LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_update)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, TSTZ}, TGEOM, + TemporalFunctions::Temporal_delete_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, TSTZ, LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SetTypes::tstzset()}, TGEOM, + TemporalFunctions::Temporal_delete_tstzset)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SetTypes::tstzset(), LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_tstzset)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpanTypes::TSTZSPAN()}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspan)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpanTypes::TSTZSPAN(), LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspan)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpansetTypes::tstzspanset()}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspanset)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpansetTypes::tstzspanset(), LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspanset)); + + // ---- Comparison (named functions + operators) ---- + struct CmpEntry { + const char *name; + scalar_function_t fn; + }; + const std::vector named_cmps = { + {"temporal_eq", TemporalFunctions::Temporal_eq}, + {"temporal_ne", TemporalFunctions::Temporal_ne}, + {"temporal_lt", TemporalFunctions::Temporal_lt}, + {"temporal_le", TemporalFunctions::Temporal_le}, + {"temporal_gt", TemporalFunctions::Temporal_gt}, + {"temporal_ge", TemporalFunctions::Temporal_ge}, + }; + for (const auto &c : named_cmps) { + loader.RegisterFunction(ScalarFunction( + c.name, {TGEOM, TGEOM}, LogicalType::BOOLEAN, c.fn)); + } + loader.RegisterFunction(ScalarFunction( + "temporal_cmp", {TGEOM, TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_cmp)); + + // Operator forms — mirror the registrations tgeometry.cpp does. + const std::vector op_cmps = { + {"=", TemporalFunctions::Temporal_eq}, + {"<>", TemporalFunctions::Temporal_ne}, + {"<", TemporalFunctions::Temporal_lt}, + {"<=", TemporalFunctions::Temporal_le}, + {">", TemporalFunctions::Temporal_gt}, + {">=", TemporalFunctions::Temporal_ge}, + }; + for (const auto &c : op_cmps) { + loader.RegisterFunction(ScalarFunction( + c.name, {TGEOM, TGEOM}, LogicalType::BOOLEAN, c.fn)); + } +} + +void TNpointTypes::RegisterTypes(ExtensionLoader &loader) { + loader.RegisterType( "TNPOINT", TNpointTypes::TNPOINT()); +} + + +} diff --git a/src/geo/tnpoint_in_out.cpp b/src/geo/tnpoint_in_out.cpp new file mode 100644 index 00000000..ea9b8e99 --- /dev/null +++ b/src/geo/tnpoint_in_out.cpp @@ -0,0 +1,315 @@ +#include "geo/tnpoint.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include "duckdb/common/extension_type_info.hpp" +#include +#include +#include +#include "mobilityduck/meos_exec_serial.hpp" + +extern "C" { + #include + #include + #include + #include + #include +} + +namespace duckdb { + +inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> string_t { + const uint8_t *data = reinterpret_cast(input_geom_str.GetData()); + size_t data_size = input_geom_str.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TNPOINT data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TNPOINT deserialization"); + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TNPOINT data: null pointer"); + } + + char *str = tspatial_as_text(temp, 0); + + if (!str) { + free(data_copy); + throw InvalidInputException("Failed to convert TNPOINT to text"); + } + + std::string result_str(str); + string_t stored_result = StringVector::AddString(result, result_str); + + free(str); + free(data_copy); + + return stored_result; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> string_t { + + const uint8_t *data = reinterpret_cast(input_geom_str.GetData()); + size_t data_size = input_geom_str.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TNPOINT data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TNPOINT deserialization"); + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TNPOINT data: null pointer"); + } + + char *ewkt = tspatial_as_ewkt(temp, 0); + + if (!ewkt) { + free(data_copy); + throw InvalidInputException("Failed to convert TNPOINT to EWKT"); + } + + std::string result_str(ewkt); + string_t stored_result = StringVector::AddString(result, result_str); + + + free(ewkt); + free(data_copy); + + return stored_result; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +bool TnpointFunctions::StringToTnpoint(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { + UnaryExecutor::Execute( + source, result, count, + [&](string_t input_string) -> string_t { + std::string input_str = input_string.GetString(); + + Temporal *temp = tnpoint_in(input_str.c_str()); + if (!temp) { + throw InvalidInputException("Invalid TNPOINT input: " + input_str); + } + + size_t data_size = temporal_mem_size(temp); + uint8_t *data_buffer = (uint8_t*)malloc(data_size); + if (!data_buffer) { + free(temp); + throw InvalidInputException("Failed to allocate memory for TNPOINT data"); + } + + memcpy(data_buffer, temp, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer), data_size); + string_t stored_data = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(temp); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } + return true; +} + +bool TnpointFunctions::TnpointToString(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { + UnaryExecutor::Execute( + source, result, count, + [&](string_t input_blob) -> string_t { + const uint8_t *data = reinterpret_cast(input_blob.GetData()); + size_t data_size = input_blob.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TNPOINT data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TNPOINT deserialization"); + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TNPOINT data: null pointer"); + } + + char *str = temporal_out(temp, 15); + if (!str) { + free(data_copy); + throw InvalidInputException("Failed to convert TNPOINT to string"); + } + + std::string output(str); + string_t stored_result = StringVector::AddString(result, output); + + free(str); + free(data_copy); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } + return true; +} + +// ---- Spatial-temporal parsers (Binary / HexWKB / MFJSON / Text) ---- +// Used to register the `tnpointFrom*` overloads. +// `temporal_from_wkb` and `temporal_from_hexwkb` are subtype-agnostic; +// `tnpoint_in` is per-type. Unlike the tcbuffer port, MEOS does not +// expose a dedicated `tnpoint_from_mfjson(const char *)` symbol: the +// network-point MF-JSON support added on MobilityDB PR #951 is wired +// through the generic `temporal_from_mfjson(mfjson, T_TNPOINT)` dispatch +// (the MovingNetworkPoint typestring with a {"route":rid,"position":pos} +// value object), exactly as the canonical MobilityDB SQL binds it to the +// generic Temporal_from_mfjson handler. The result is stored as a raw +// blob, the same format every other temporal type uses. + +inline string_t StoreTempAsBlob(Vector &result, Temporal *t) { + size_t sz = temporal_mem_size(t); + string_t stored = StringVector::AddStringOrBlob( + result, string_t(reinterpret_cast(t), sz)); + free(t); + return stored; +} + +inline void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + if (input.GetSize() == 0) + throw InvalidInputException("fromBinary: empty WKB input"); + uint8_t *wkb = (uint8_t *)malloc(input.GetSize()); + if (!wkb) throw InternalException("fromBinary: malloc failed"); + memcpy(wkb, input.GetData(), input.GetSize()); + Temporal *t = temporal_from_wkb(wkb, input.GetSize()); + free(wkb); + if (!t) throw InvalidInputException("fromBinary: invalid MEOS-WKB"); + return StoreTempAsBlob(result, t); + }); +} + +inline void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + std::string hex(input.GetData(), input.GetSize()); + Temporal *t = temporal_from_hexwkb(hex.c_str()); + if (!t) throw InvalidInputException( + "fromHexWKB: invalid hex-encoded MEOS-WKB"); + return StoreTempAsBlob(result, t); + }); +} + +inline void TnpointFromTextExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + std::string s(input.GetData(), input.GetSize()); + Temporal *t = tnpoint_in(s.c_str()); + if (!t) throw InvalidInputException("from*: invalid input"); + return StoreTempAsBlob(result, t); + }); +} + +inline void TnpointFromMFJSONExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + std::string s(input.GetData(), input.GetSize()); + // tnpoint has no dedicated *_from_mfjson symbol; route through + // the generic dispatch with the T_TNPOINT temporal type, the + // same path the canonical MobilityDB SQL binds. + Temporal *t = temporal_from_mfjson(s.c_str(), T_TNPOINT); + if (!t) throw InvalidInputException("fromMFJSON: invalid input"); + return StoreTempAsBlob(result, t); + }); +} + +void TNpointTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ + auto TnpointAsText = ScalarFunction( + "asText", + {TNpointTypes::TNPOINT()}, + LogicalType::VARCHAR, + Tspatial_as_text + ); + duckdb::RegisterSerializedScalarFunction(loader, TnpointAsText); + + auto TnpointAsEWKT = ScalarFunction( + "asEWKT", + {TNpointTypes::TNPOINT()}, + LogicalType::VARCHAR, + Tspatial_as_ewkt + ); + duckdb::RegisterSerializedScalarFunction(loader, TnpointAsEWKT); + + // ---- tnpointFromBinary / FromEWKB (auto-detects format) ---- + const auto B = LogicalType::BLOB; + const auto V = LogicalType::VARCHAR; + const auto T = TNpointTypes::TNPOINT(); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tnpointFromBinary", {B}, T, TspatialFromWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tnpointFromEWKB", {B}, T, TspatialFromWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tnpointFromHexWKB", {V}, T, TspatialFromHexWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tnpointFromHexEWKB", {V}, T, TspatialFromHexWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tnpointFromMFJSON", {V}, T, TnpointFromMFJSONExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tnpointFromText", {V}, T, TnpointFromTextExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tnpointFromEWKT", {V}, T, TnpointFromTextExec)); +} + + +void TNpointTypes::RegisterCastFunctions(ExtensionLoader &loader) { + loader.RegisterCastFunction( LogicalType::VARCHAR, TNpointTypes::TNPOINT(), TnpointFunctions::StringToTnpoint); + loader.RegisterCastFunction( TNpointTypes::TNPOINT(), LogicalType::VARCHAR, TnpointFunctions::TnpointToString); +} + +} diff --git a/src/include/geo/tnpoint.hpp b/src/include/geo/tnpoint.hpp new file mode 100644 index 00000000..023fa261 --- /dev/null +++ b/src/include/geo/tnpoint.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include +#include "duckdb/common/exception.hpp" +#include "duckdb/common/string_util.hpp" +#include "duckdb/function/scalar_function.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include + +namespace duckdb { + + +struct TNpointTypes { + static LogicalType TNPOINT(); + static LogicalType GEOMETRY(); + static void RegisterTypes(ExtensionLoader &loader); + static void RegisterScalarFunctions(ExtensionLoader &loader); + static void RegisterCastFunctions(ExtensionLoader &loader); + static void RegisterScalarInOutFunctions(ExtensionLoader &loader); +}; + +struct TnpointFunctions { + static bool StringToTnpoint(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + static bool TnpointToString(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + static bool WkbBlobToGeometry(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); +}; + + +} // namespace duckdb diff --git a/src/mobilityduck_extension.cpp b/src/mobilityduck_extension.cpp index 07db18d1..d49971fe 100644 --- a/src/mobilityduck_extension.cpp +++ b/src/mobilityduck_extension.cpp @@ -14,6 +14,12 @@ #if CBUFFER #include "geo/tcbuffer.hpp" #endif +#if NPOINT +#include "geo/tnpoint.hpp" +// MEOS resolves tnpoint route geometries from a ways CSV at a hardcoded path; +// the canonical ways1000.csv is embedded and materialized there on load. +#include "ways_csv.inc" +#endif #include "geo/tgeometry.hpp" #include "geo/tgeometry_ops.hpp" #include "geo/tgeography.hpp" @@ -212,6 +218,31 @@ extern "C" void MobilityduckMeosErrorHandler(int errlevel, int errcode, const ch // 5. Extension load logic // ===================================================================== +#if NPOINT +// MEOS reads the ways CSV from a hardcoded path with no setter, so the embedded +// copy is materialized there. Best-effort: if the file already exists or the +// path is not writable, leave it — route-bearing tnpoint operations then return +// a clear MEOS "cannot open the ways CSV file" error rather than crashing. +static const char *const MDUCK_WAYS_CSV_PATH = "/usr/local/share/ways1000.csv"; + +static void EnsureEmbeddedWaysCsvOnDisk() { + static std::once_flag once; + std::call_once(once, [] { + if (file_exists(MDUCK_WAYS_CSV_PATH)) { + return; + } + std::ofstream out(MDUCK_WAYS_CSV_PATH, std::ios::binary); + if (!out) { + return; + } + out.write( + reinterpret_cast(ways1000_csv), + static_cast(ways1000_csv_len) + ); + }); +} +#endif + static void LoadInternal(ExtensionLoader &loader) { // Configure MEOS SRID CSV once (env / embedded) ConfigureMeosSridCsvOnce(); @@ -343,6 +374,16 @@ static void LoadInternal(ExtensionLoader &loader) { TCBufferTypes::RegisterScalarInOutFunctions(loader); #endif + // Extended temporal type tnpoint (requires the MEOS NPOINT module and the + // embedded ways CSV materialized above). +#if NPOINT + EnsureEmbeddedWaysCsvOnDisk(); + TNpointTypes::RegisterScalarFunctions(loader); + TNpointTypes::RegisterTypes(loader); + TNpointTypes::RegisterCastFunctions(loader); + TNpointTypes::RegisterScalarInOutFunctions(loader); +#endif + SetTypes::RegisterTypes(loader); SetTypes::RegisterCastFunctions(loader); SetTypes::RegisterScalarFunctions(loader); diff --git a/src/ways_csv.inc b/src/ways_csv.inc new file mode 100644 index 00000000..54b2bef3 --- /dev/null +++ b/src/ways_csv.inc @@ -0,0 +1,10426 @@ +unsigned char ways1000_csv[] = { + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x39, 0x33, + 0x36, 0x39, 0x38, 0x41, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x44, 0x32, 0x43, 0x30, 0x38, 0x33, 0x35, 0x35, 0x35, 0x36, 0x34, 0x30, + 0x38, 0x38, 0x38, 0x42, 0x33, 0x45, 0x41, 0x33, 0x30, 0x32, 0x41, 0x43, + 0x34, 0x44, 0x34, 0x30, 0x33, 0x46, 0x30, 0x34, 0x42, 0x45, 0x39, 0x45, + 0x31, 0x32, 0x42, 0x37, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x32, 0x46, 0x36, 0x31, 0x46, 0x44, + 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x45, 0x30, + 0x30, 0x43, 0x38, 0x38, 0x35, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x41, 0x37, 0x31, 0x32, 0x41, 0x34, 0x35, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x35, 0x35, 0x35, 0x32, 0x34, + 0x44, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x31, + 0x45, 0x46, 0x34, 0x31, 0x38, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x32, 0x43, 0x43, 0x32, 0x45, 0x46, 0x34, 0x35, 0x31, 0x34, + 0x30, 0x0a, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x41, 0x31, 0x35, 0x42, 0x34, 0x30, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x45, 0x38, 0x33, 0x36, 0x36, 0x32, 0x35, 0x38, + 0x34, 0x30, 0x45, 0x38, 0x36, 0x37, 0x42, 0x36, 0x42, 0x30, 0x33, 0x41, + 0x32, 0x42, 0x34, 0x32, 0x34, 0x30, 0x35, 0x31, 0x42, 0x44, 0x46, 0x41, + 0x39, 0x46, 0x45, 0x36, 0x31, 0x39, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x37, 0x30, 0x35, + 0x44, 0x35, 0x41, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x43, 0x32, 0x43, 0x46, 0x32, 0x33, 0x37, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, 0x41, 0x30, 0x36, 0x36, 0x41, 0x33, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x42, 0x41, + 0x30, 0x46, 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x34, 0x38, 0x35, 0x35, 0x30, 0x41, 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x41, 0x33, 0x30, 0x39, 0x34, 0x30, + 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x36, 0x43, 0x36, + 0x38, 0x37, 0x42, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x43, 0x45, 0x43, 0x46, 0x35, 0x44, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x43, 0x44, 0x42, 0x46, 0x33, 0x33, 0x39, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, 0x46, 0x30, 0x38, + 0x36, 0x44, 0x45, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x39, 0x34, 0x33, 0x30, 0x46, + 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x34, + 0x39, 0x33, 0x33, 0x34, 0x32, 0x32, 0x34, 0x30, 0x38, 0x32, 0x42, 0x44, + 0x38, 0x36, 0x37, 0x34, 0x35, 0x37, 0x39, 0x44, 0x34, 0x44, 0x34, 0x30, + 0x36, 0x41, 0x44, 0x32, 0x46, 0x34, 0x34, 0x35, 0x39, 0x37, 0x38, 0x37, + 0x32, 0x46, 0x34, 0x30, 0x0a, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x30, 0x42, 0x36, 0x33, 0x36, 0x35, 0x31, 0x30, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x43, 0x42, 0x46, 0x36, 0x42, + 0x39, 0x35, 0x35, 0x34, 0x30, 0x37, 0x34, 0x39, 0x41, 0x41, 0x44, 0x42, + 0x45, 0x31, 0x35, 0x39, 0x41, 0x32, 0x46, 0x34, 0x30, 0x38, 0x33, 0x39, + 0x44, 0x37, 0x46, 0x41, 0x36, 0x43, 0x31, 0x32, 0x46, 0x33, 0x43, 0x34, + 0x30, 0x0a, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x42, 0x46, 0x34, 0x38, 0x44, 0x37, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x30, 0x36, 0x30, 0x35, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x41, 0x38, 0x42, 0x33, 0x38, + 0x42, 0x42, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, + 0x38, 0x31, 0x32, 0x43, 0x45, 0x41, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x34, 0x35, 0x38, 0x36, 0x33, 0x41, 0x37, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x44, 0x45, 0x36, 0x34, + 0x30, 0x30, 0x33, 0x34, 0x34, 0x30, 0x44, 0x38, 0x33, 0x33, 0x35, 0x34, + 0x32, 0x45, 0x30, 0x46, 0x43, 0x30, 0x35, 0x37, 0x34, 0x30, 0x44, 0x31, + 0x42, 0x44, 0x39, 0x44, 0x34, 0x39, 0x45, 0x33, 0x43, 0x36, 0x33, 0x35, + 0x34, 0x30, 0x0a, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x45, 0x39, 0x34, 0x31, 0x31, 0x39, 0x44, 0x35, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x30, 0x34, 0x42, 0x35, 0x32, 0x33, 0x46, 0x31, + 0x45, 0x34, 0x30, 0x39, 0x45, 0x30, 0x30, 0x42, 0x33, 0x42, 0x30, 0x46, + 0x41, 0x36, 0x39, 0x34, 0x43, 0x34, 0x30, 0x36, 0x34, 0x44, 0x44, 0x31, + 0x38, 0x38, 0x41, 0x42, 0x31, 0x35, 0x36, 0x34, 0x43, 0x34, 0x30, 0x0a, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x39, 0x30, + 0x46, 0x42, 0x45, 0x41, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x43, 0x30, 0x35, 0x30, 0x30, 0x46, 0x45, 0x34, 0x44, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x33, 0x46, 0x42, 0x45, 0x35, 0x42, + 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x34, + 0x34, 0x35, 0x36, 0x44, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x36, 0x46, 0x39, 0x30, 0x31, + 0x31, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, + 0x30, 0x32, 0x44, 0x39, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x35, 0x46, 0x31, 0x44, 0x34, 0x42, 0x33, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x32, 0x45, 0x39, 0x45, + 0x35, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x43, + 0x31, 0x46, 0x33, 0x45, 0x41, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x31, 0x46, 0x43, 0x31, 0x32, 0x35, 0x34, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x36, 0x36, 0x32, 0x33, 0x34, 0x30, + 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, + 0x38, 0x33, 0x37, 0x42, 0x30, 0x32, 0x36, 0x34, 0x30, 0x0a, 0x31, 0x30, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x41, 0x44, 0x31, + 0x32, 0x36, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x34, 0x34, 0x33, 0x31, 0x41, 0x39, 0x31, 0x41, 0x34, 0x30, 0x39, + 0x44, 0x45, 0x31, 0x45, 0x37, 0x31, 0x33, 0x32, 0x45, 0x39, 0x37, 0x35, + 0x35, 0x34, 0x30, 0x31, 0x45, 0x33, 0x32, 0x42, 0x37, 0x46, 0x30, 0x41, + 0x41, 0x42, 0x41, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x31, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x39, 0x45, 0x36, 0x37, + 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, + 0x35, 0x39, 0x45, 0x38, 0x32, 0x34, 0x45, 0x34, 0x30, 0x45, 0x33, 0x41, + 0x32, 0x39, 0x41, 0x41, 0x35, 0x33, 0x39, 0x43, 0x31, 0x34, 0x46, 0x34, + 0x30, 0x34, 0x43, 0x39, 0x43, 0x38, 0x34, 0x32, 0x35, 0x37, 0x39, 0x43, + 0x42, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x31, 0x32, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x45, 0x31, 0x36, 0x39, 0x31, 0x43, 0x46, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x42, 0x39, 0x35, + 0x33, 0x39, 0x45, 0x34, 0x34, 0x34, 0x30, 0x34, 0x31, 0x45, 0x31, 0x41, + 0x45, 0x35, 0x39, 0x45, 0x38, 0x35, 0x35, 0x34, 0x30, 0x34, 0x30, 0x39, + 0x43, 0x34, 0x35, 0x33, 0x42, 0x39, 0x33, 0x35, 0x37, 0x32, 0x31, 0x32, + 0x44, 0x34, 0x30, 0x0a, 0x31, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x36, 0x37, 0x42, 0x34, 0x43, 0x45, 0x46, 0x32, 0x33, + 0x46, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x39, 0x37, 0x33, 0x30, 0x43, + 0x30, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x41, 0x30, + 0x46, 0x44, 0x45, 0x32, 0x34, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x43, 0x35, 0x33, 0x41, 0x36, 0x42, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x42, 0x38, 0x41, 0x39, 0x38, + 0x43, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x34, 0x36, + 0x42, 0x43, 0x39, 0x30, 0x46, 0x35, 0x34, 0x34, 0x30, 0x0a, 0x31, 0x34, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x46, 0x38, 0x45, + 0x33, 0x37, 0x45, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x43, 0x35, 0x35, 0x44, 0x32, 0x46, 0x42, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x43, 0x39, 0x44, 0x36, 0x41, 0x44, 0x38, 0x34, + 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x46, 0x39, + 0x45, 0x41, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x32, 0x34, 0x30, 0x31, 0x32, 0x41, 0x32, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x30, 0x43, 0x33, 0x34, 0x38, 0x31, 0x32, 0x32, + 0x43, 0x34, 0x30, 0x0a, 0x31, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x41, 0x46, 0x34, 0x36, 0x45, 0x33, 0x34, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x45, 0x42, 0x45, 0x35, 0x41, + 0x32, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x32, + 0x42, 0x39, 0x37, 0x35, 0x42, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x35, 0x43, 0x31, 0x33, 0x34, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x30, 0x41, 0x41, 0x38, 0x33, + 0x44, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x32, + 0x30, 0x38, 0x35, 0x36, 0x36, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x34, 0x31, 0x30, 0x31, 0x34, 0x36, 0x42, 0x34, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x41, 0x38, 0x42, 0x42, + 0x35, 0x30, 0x30, 0x34, 0x30, 0x0a, 0x31, 0x36, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x32, 0x34, 0x35, 0x36, 0x30, 0x43, 0x39, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x31, 0x33, 0x31, + 0x36, 0x30, 0x32, 0x35, 0x30, 0x34, 0x30, 0x45, 0x41, 0x30, 0x35, 0x45, + 0x34, 0x38, 0x31, 0x37, 0x30, 0x41, 0x44, 0x35, 0x34, 0x34, 0x30, 0x42, + 0x30, 0x42, 0x37, 0x37, 0x37, 0x39, 0x43, 0x38, 0x32, 0x46, 0x32, 0x34, + 0x41, 0x34, 0x30, 0x0a, 0x31, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x33, 0x36, 0x46, 0x32, 0x43, 0x39, 0x31, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x41, 0x36, 0x31, 0x43, 0x37, + 0x44, 0x33, 0x36, 0x34, 0x30, 0x33, 0x35, 0x31, 0x39, 0x36, 0x42, 0x41, + 0x45, 0x35, 0x32, 0x31, 0x42, 0x33, 0x30, 0x34, 0x30, 0x42, 0x35, 0x37, + 0x39, 0x45, 0x33, 0x34, 0x36, 0x33, 0x39, 0x42, 0x30, 0x34, 0x33, 0x34, + 0x30, 0x0a, 0x31, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x43, 0x43, 0x46, 0x33, 0x34, 0x46, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x45, 0x43, 0x31, 0x42, 0x36, 0x39, 0x36, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x39, 0x41, 0x33, + 0x39, 0x45, 0x37, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x30, 0x32, 0x39, 0x32, 0x41, 0x37, 0x37, 0x34, 0x42, 0x34, 0x30, 0x34, + 0x45, 0x31, 0x31, 0x36, 0x44, 0x36, 0x42, 0x38, 0x36, 0x39, 0x30, 0x33, + 0x44, 0x34, 0x30, 0x44, 0x43, 0x44, 0x42, 0x42, 0x46, 0x46, 0x46, 0x42, + 0x44, 0x36, 0x35, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x31, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x30, 0x31, 0x43, 0x45, 0x41, + 0x44, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x41, + 0x31, 0x34, 0x38, 0x42, 0x33, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x45, 0x33, 0x45, 0x45, 0x41, 0x30, 0x34, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x46, 0x46, 0x34, 0x34, 0x46, + 0x38, 0x35, 0x38, 0x34, 0x30, 0x43, 0x35, 0x43, 0x37, 0x35, 0x45, 0x30, + 0x45, 0x46, 0x45, 0x43, 0x45, 0x34, 0x32, 0x34, 0x30, 0x43, 0x33, 0x43, + 0x44, 0x30, 0x34, 0x44, 0x31, 0x42, 0x41, 0x30, 0x41, 0x34, 0x42, 0x34, + 0x30, 0x0a, 0x32, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x38, 0x34, 0x46, 0x31, 0x46, 0x41, 0x42, 0x33, 0x46, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x30, 0x36, 0x33, 0x30, 0x46, 0x44, 0x36, 0x32, + 0x31, 0x34, 0x30, 0x33, 0x43, 0x33, 0x35, 0x45, 0x45, 0x37, 0x34, 0x32, + 0x32, 0x44, 0x38, 0x34, 0x42, 0x34, 0x30, 0x37, 0x30, 0x38, 0x38, 0x44, + 0x31, 0x43, 0x43, 0x39, 0x39, 0x35, 0x42, 0x34, 0x39, 0x34, 0x30, 0x0a, + 0x32, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, + 0x37, 0x37, 0x33, 0x31, 0x43, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x38, 0x37, 0x45, 0x37, 0x39, 0x33, 0x38, 0x34, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x31, 0x37, 0x36, 0x38, 0x32, + 0x35, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x32, + 0x34, 0x46, 0x33, 0x44, 0x34, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x34, 0x35, 0x34, 0x35, 0x33, 0x42, 0x39, 0x35, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x35, 0x45, 0x43, 0x43, 0x43, + 0x31, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, + 0x34, 0x41, 0x36, 0x33, 0x36, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x33, 0x35, 0x44, 0x38, 0x37, 0x35, 0x35, 0x32, 0x34, + 0x30, 0x0a, 0x32, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x38, 0x43, 0x43, 0x34, 0x34, 0x43, 0x37, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x34, 0x46, 0x41, 0x41, 0x41, 0x37, 0x39, 0x34, + 0x31, 0x34, 0x30, 0x46, 0x33, 0x37, 0x41, 0x43, 0x31, 0x41, 0x42, 0x34, + 0x37, 0x35, 0x43, 0x34, 0x42, 0x34, 0x30, 0x31, 0x33, 0x30, 0x46, 0x46, + 0x46, 0x36, 0x33, 0x42, 0x30, 0x42, 0x44, 0x34, 0x31, 0x34, 0x30, 0x0a, + 0x32, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x32, + 0x38, 0x44, 0x38, 0x35, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x30, 0x33, 0x33, 0x33, 0x31, 0x45, 0x42, 0x33, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x36, 0x33, 0x32, 0x34, 0x41, + 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x34, 0x37, + 0x35, 0x39, 0x44, 0x31, 0x46, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x32, 0x34, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x41, 0x30, 0x37, + 0x37, 0x43, 0x31, 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x36, 0x39, 0x42, 0x34, 0x37, 0x37, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x45, 0x35, 0x39, 0x33, 0x42, 0x39, 0x35, 0x35, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x33, 0x31, 0x34, + 0x34, 0x31, 0x35, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x38, 0x32, 0x36, 0x42, 0x36, 0x44, 0x34, 0x33, 0x46, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x31, 0x38, 0x36, 0x44, 0x38, 0x33, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x45, 0x41, + 0x34, 0x41, 0x30, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x30, 0x45, 0x41, 0x35, 0x42, 0x42, 0x30, 0x31, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x42, 0x37, 0x44, 0x34, 0x46, 0x45, 0x31, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x33, 0x31, + 0x41, 0x31, 0x31, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x32, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, 0x36, 0x34, 0x39, 0x42, 0x46, + 0x35, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x33, + 0x35, 0x33, 0x35, 0x30, 0x37, 0x34, 0x46, 0x34, 0x30, 0x31, 0x33, 0x31, + 0x34, 0x43, 0x44, 0x35, 0x43, 0x44, 0x37, 0x35, 0x39, 0x35, 0x32, 0x34, + 0x30, 0x44, 0x41, 0x45, 0x37, 0x44, 0x44, 0x42, 0x33, 0x39, 0x39, 0x39, + 0x44, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x32, 0x36, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x30, 0x38, 0x41, 0x32, 0x38, 0x43, 0x36, 0x34, + 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x32, 0x37, 0x31, + 0x34, 0x35, 0x45, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x38, 0x32, 0x31, 0x44, 0x44, 0x37, 0x34, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x36, 0x43, 0x36, 0x34, 0x37, 0x32, 0x41, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x32, 0x41, 0x44, + 0x33, 0x42, 0x35, 0x31, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x41, 0x30, 0x45, 0x35, 0x42, 0x45, 0x36, 0x35, 0x30, 0x34, 0x30, 0x0a, + 0x32, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x34, 0x35, 0x35, 0x35, 0x46, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x30, 0x30, 0x42, 0x45, 0x33, 0x39, 0x31, 0x32, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x31, 0x32, 0x43, 0x41, 0x37, + 0x43, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x42, + 0x42, 0x41, 0x39, 0x30, 0x44, 0x34, 0x38, 0x34, 0x30, 0x35, 0x42, 0x41, + 0x41, 0x33, 0x36, 0x36, 0x42, 0x35, 0x39, 0x42, 0x45, 0x35, 0x32, 0x34, + 0x30, 0x42, 0x39, 0x31, 0x37, 0x34, 0x41, 0x31, 0x35, 0x46, 0x45, 0x41, + 0x42, 0x34, 0x39, 0x34, 0x30, 0x0a, 0x32, 0x38, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x43, 0x32, 0x30, 0x35, 0x41, 0x37, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x38, 0x38, 0x38, + 0x44, 0x33, 0x42, 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x45, 0x37, 0x43, 0x43, 0x38, 0x46, 0x38, 0x33, 0x46, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x34, 0x42, 0x41, 0x34, 0x30, 0x35, 0x35, 0x34, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x41, 0x36, 0x31, 0x44, + 0x35, 0x37, 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x36, 0x38, 0x46, 0x46, 0x38, 0x36, 0x36, 0x35, 0x36, 0x34, 0x30, 0x0a, + 0x32, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x32, 0x46, + 0x38, 0x41, 0x35, 0x46, 0x44, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x45, 0x34, 0x45, 0x43, 0x43, 0x42, 0x33, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, 0x45, 0x44, 0x37, 0x38, 0x46, + 0x39, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x41, 0x36, + 0x32, 0x45, 0x42, 0x35, 0x33, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x36, 0x33, 0x31, 0x46, 0x34, 0x33, 0x46, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, 0x36, 0x37, 0x36, 0x39, 0x36, + 0x34, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x39, + 0x45, 0x46, 0x45, 0x44, 0x42, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x36, 0x33, 0x42, 0x37, 0x39, 0x39, 0x37, 0x35, 0x37, 0x34, + 0x30, 0x0a, 0x33, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x38, 0x36, 0x45, 0x34, 0x37, 0x36, 0x31, 0x35, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x41, 0x30, 0x39, 0x42, 0x42, 0x35, 0x46, + 0x30, 0x33, 0x46, 0x35, 0x46, 0x43, 0x41, 0x32, 0x43, 0x44, 0x41, 0x46, + 0x36, 0x32, 0x38, 0x32, 0x32, 0x34, 0x30, 0x37, 0x34, 0x38, 0x31, 0x43, + 0x31, 0x34, 0x44, 0x43, 0x39, 0x34, 0x46, 0x34, 0x30, 0x34, 0x30, 0x0a, + 0x33, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x35, + 0x37, 0x38, 0x32, 0x42, 0x36, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x36, 0x30, 0x39, 0x35, 0x38, 0x34, 0x46, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x30, 0x38, 0x43, 0x32, 0x44, + 0x45, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x34, + 0x38, 0x34, 0x45, 0x42, 0x36, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x43, 0x43, 0x35, 0x44, 0x46, 0x36, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x43, 0x38, 0x32, 0x37, 0x30, + 0x44, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x32, + 0x46, 0x39, 0x32, 0x37, 0x43, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x41, 0x35, 0x46, 0x38, 0x38, 0x33, 0x33, 0x38, 0x34, + 0x30, 0x0a, 0x33, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x34, 0x45, 0x38, 0x33, 0x34, 0x41, 0x34, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x34, 0x39, 0x39, 0x39, 0x32, 0x46, 0x36, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x33, 0x46, 0x30, + 0x46, 0x37, 0x37, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x30, 0x44, 0x35, 0x33, 0x37, 0x36, 0x34, 0x33, 0x39, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x38, 0x45, 0x39, 0x30, 0x38, 0x44, 0x33, 0x33, + 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x34, 0x33, 0x46, + 0x35, 0x39, 0x35, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x33, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x36, 0x41, 0x45, 0x36, + 0x34, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x34, + 0x39, 0x46, 0x41, 0x30, 0x31, 0x35, 0x35, 0x34, 0x30, 0x33, 0x32, 0x32, + 0x33, 0x33, 0x39, 0x30, 0x38, 0x41, 0x30, 0x34, 0x35, 0x34, 0x43, 0x34, + 0x30, 0x31, 0x37, 0x46, 0x42, 0x45, 0x42, 0x30, 0x41, 0x34, 0x41, 0x45, + 0x30, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x33, 0x34, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x38, 0x33, 0x44, 0x38, 0x33, 0x35, 0x42, 0x34, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x34, 0x30, 0x36, + 0x42, 0x34, 0x39, 0x34, 0x34, 0x34, 0x30, 0x39, 0x45, 0x42, 0x35, 0x31, + 0x44, 0x37, 0x36, 0x37, 0x38, 0x37, 0x37, 0x34, 0x35, 0x34, 0x30, 0x38, + 0x41, 0x46, 0x36, 0x32, 0x42, 0x41, 0x35, 0x32, 0x30, 0x45, 0x41, 0x34, + 0x42, 0x34, 0x30, 0x0a, 0x33, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x38, 0x36, 0x44, 0x37, 0x42, 0x37, 0x34, 0x34, 0x41, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, 0x43, 0x38, 0x44, 0x30, + 0x34, 0x32, 0x35, 0x34, 0x30, 0x46, 0x45, 0x42, 0x31, 0x44, 0x46, 0x41, + 0x36, 0x44, 0x42, 0x32, 0x45, 0x35, 0x30, 0x34, 0x30, 0x35, 0x43, 0x39, + 0x43, 0x39, 0x36, 0x35, 0x45, 0x31, 0x41, 0x43, 0x42, 0x33, 0x41, 0x34, + 0x30, 0x0a, 0x33, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x39, 0x32, 0x39, 0x30, 0x44, 0x33, 0x32, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x43, 0x34, 0x45, 0x39, 0x32, 0x30, 0x43, 0x34, + 0x32, 0x34, 0x30, 0x32, 0x35, 0x36, 0x38, 0x39, 0x31, 0x35, 0x46, 0x36, + 0x30, 0x39, 0x36, 0x33, 0x43, 0x34, 0x30, 0x33, 0x34, 0x46, 0x34, 0x34, + 0x34, 0x33, 0x41, 0x38, 0x42, 0x38, 0x30, 0x34, 0x46, 0x34, 0x30, 0x0a, + 0x33, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x38, + 0x30, 0x41, 0x32, 0x32, 0x42, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x35, 0x35, 0x34, 0x38, 0x31, 0x46, 0x34, 0x41, 0x34, + 0x30, 0x37, 0x38, 0x35, 0x45, 0x38, 0x35, 0x33, 0x42, 0x36, 0x30, 0x38, + 0x43, 0x32, 0x45, 0x34, 0x30, 0x42, 0x45, 0x43, 0x39, 0x43, 0x33, 0x44, + 0x33, 0x35, 0x36, 0x32, 0x45, 0x34, 0x45, 0x34, 0x30, 0x0a, 0x33, 0x38, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x44, 0x35, 0x36, + 0x46, 0x44, 0x37, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x34, 0x44, 0x39, 0x44, 0x36, 0x34, 0x33, 0x35, 0x32, 0x34, 0x30, 0x45, + 0x42, 0x41, 0x37, 0x33, 0x31, 0x37, 0x39, 0x46, 0x31, 0x32, 0x36, 0x35, + 0x31, 0x34, 0x30, 0x33, 0x42, 0x31, 0x34, 0x45, 0x33, 0x33, 0x39, 0x41, + 0x42, 0x45, 0x34, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x33, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x45, 0x41, 0x46, 0x38, 0x36, 0x44, + 0x45, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x45, 0x31, + 0x35, 0x34, 0x43, 0x31, 0x32, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x41, 0x38, 0x39, 0x30, 0x42, 0x30, 0x34, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x46, 0x46, 0x46, 0x41, 0x45, + 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x38, + 0x30, 0x45, 0x30, 0x34, 0x33, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x32, 0x42, 0x37, 0x30, 0x39, 0x42, 0x34, 0x39, 0x34, + 0x30, 0x42, 0x45, 0x33, 0x42, 0x31, 0x32, 0x41, 0x32, 0x41, 0x45, 0x34, + 0x34, 0x34, 0x36, 0x34, 0x30, 0x43, 0x35, 0x46, 0x39, 0x46, 0x46, 0x33, + 0x31, 0x36, 0x41, 0x38, 0x34, 0x34, 0x34, 0x34, 0x30, 0x0a, 0x34, 0x30, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x32, 0x43, 0x34, 0x32, + 0x35, 0x45, 0x42, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x41, 0x32, 0x32, 0x45, 0x30, 0x42, 0x45, 0x35, 0x30, 0x34, 0x30, 0x36, + 0x35, 0x37, 0x31, 0x44, 0x38, 0x42, 0x46, 0x41, 0x42, 0x36, 0x43, 0x35, + 0x35, 0x34, 0x30, 0x46, 0x30, 0x38, 0x30, 0x43, 0x32, 0x33, 0x35, 0x43, + 0x38, 0x44, 0x33, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x34, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x38, 0x43, 0x32, 0x33, 0x34, + 0x42, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, + 0x31, 0x43, 0x31, 0x43, 0x42, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x45, 0x45, 0x39, 0x39, 0x34, 0x33, 0x31, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x44, 0x32, 0x45, 0x42, 0x36, + 0x43, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, + 0x43, 0x37, 0x39, 0x41, 0x45, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x30, 0x44, 0x39, 0x42, 0x36, 0x35, 0x38, 0x32, 0x45, 0x34, + 0x30, 0x0a, 0x34, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x43, 0x35, 0x39, 0x32, 0x31, 0x36, 0x35, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x38, 0x38, 0x32, 0x35, 0x46, 0x38, 0x34, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x36, 0x36, 0x33, + 0x31, 0x34, 0x30, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x38, 0x34, 0x36, 0x46, 0x37, 0x46, 0x35, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x32, 0x37, 0x44, 0x42, 0x38, 0x39, 0x30, 0x35, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, + 0x34, 0x45, 0x46, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x34, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x43, 0x33, 0x45, 0x44, 0x45, + 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, + 0x46, 0x44, 0x34, 0x45, 0x45, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x30, 0x32, 0x35, 0x39, 0x43, 0x35, 0x32, 0x32, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x45, 0x35, 0x43, 0x44, 0x41, + 0x36, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x34, 0x34, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x38, 0x42, 0x36, 0x34, 0x32, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x46, 0x41, 0x42, + 0x37, 0x44, 0x38, 0x32, 0x42, 0x34, 0x30, 0x31, 0x33, 0x43, 0x36, 0x31, + 0x42, 0x34, 0x45, 0x38, 0x32, 0x33, 0x41, 0x34, 0x45, 0x34, 0x30, 0x42, + 0x39, 0x42, 0x34, 0x31, 0x45, 0x33, 0x44, 0x37, 0x30, 0x46, 0x32, 0x32, + 0x38, 0x34, 0x30, 0x0a, 0x34, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x34, 0x34, 0x35, 0x34, 0x42, 0x45, 0x43, 0x35, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x38, 0x34, 0x38, + 0x38, 0x44, 0x30, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x38, + 0x36, 0x46, 0x44, 0x44, 0x34, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x34, 0x30, 0x44, 0x46, 0x36, 0x35, 0x43, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x41, 0x42, 0x39, 0x35, + 0x30, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, + 0x32, 0x46, 0x32, 0x39, 0x46, 0x34, 0x34, 0x34, 0x30, 0x45, 0x36, 0x35, + 0x35, 0x45, 0x46, 0x38, 0x43, 0x32, 0x38, 0x36, 0x38, 0x34, 0x33, 0x34, + 0x30, 0x42, 0x46, 0x38, 0x39, 0x34, 0x45, 0x43, 0x43, 0x45, 0x43, 0x36, + 0x46, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x34, 0x36, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x46, 0x30, 0x35, 0x44, 0x30, 0x34, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x33, 0x33, 0x44, + 0x37, 0x43, 0x39, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x32, 0x37, 0x32, 0x39, 0x37, 0x36, 0x31, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x43, 0x38, 0x37, 0x38, 0x41, 0x45, 0x37, 0x34, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x42, 0x39, 0x32, + 0x37, 0x39, 0x32, 0x33, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x30, 0x42, 0x34, 0x42, 0x36, 0x36, 0x30, 0x35, 0x30, 0x34, 0x30, 0x0a, + 0x34, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x45, + 0x35, 0x43, 0x44, 0x44, 0x32, 0x34, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x43, 0x32, 0x34, 0x30, 0x36, 0x45, 0x37, 0x34, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x35, 0x43, 0x33, 0x32, 0x30, + 0x39, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x43, + 0x31, 0x37, 0x33, 0x34, 0x39, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x43, 0x41, 0x37, 0x44, 0x42, 0x36, 0x33, 0x34, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x43, 0x45, 0x39, 0x31, 0x43, + 0x33, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x43, + 0x41, 0x38, 0x34, 0x36, 0x41, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x42, 0x33, 0x44, 0x36, 0x30, 0x44, 0x34, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x37, 0x41, 0x35, 0x46, 0x31, + 0x46, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, + 0x31, 0x43, 0x35, 0x35, 0x46, 0x31, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x38, 0x33, 0x45, 0x34, 0x35, 0x36, 0x35, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x46, 0x45, 0x39, 0x32, 0x44, + 0x45, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x34, 0x38, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x42, 0x31, 0x32, 0x44, 0x31, 0x38, 0x33, + 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x39, 0x44, + 0x31, 0x31, 0x36, 0x33, 0x32, 0x34, 0x30, 0x45, 0x43, 0x46, 0x45, 0x41, + 0x44, 0x36, 0x30, 0x39, 0x30, 0x37, 0x38, 0x34, 0x33, 0x34, 0x30, 0x41, + 0x36, 0x34, 0x33, 0x35, 0x46, 0x42, 0x39, 0x45, 0x31, 0x31, 0x34, 0x33, + 0x42, 0x34, 0x30, 0x0a, 0x34, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x38, 0x35, 0x36, 0x43, 0x42, 0x30, 0x33, 0x34, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x35, 0x34, 0x35, 0x39, 0x43, + 0x41, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x42, + 0x43, 0x45, 0x30, 0x36, 0x45, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x45, 0x30, 0x43, 0x39, 0x42, 0x34, 0x31, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x43, 0x44, 0x42, 0x38, 0x37, + 0x42, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, + 0x33, 0x43, 0x46, 0x39, 0x42, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x30, 0x46, 0x44, 0x30, 0x43, 0x32, 0x30, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x33, 0x41, 0x43, 0x41, 0x36, + 0x46, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x35, 0x30, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x45, 0x34, 0x34, 0x38, 0x34, 0x35, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x41, 0x32, 0x41, + 0x43, 0x42, 0x35, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x43, 0x35, 0x45, 0x45, 0x31, 0x44, 0x32, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x41, 0x33, 0x34, 0x34, 0x35, 0x43, 0x42, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x45, 0x31, 0x37, 0x39, + 0x41, 0x43, 0x44, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x30, 0x42, 0x42, 0x38, 0x36, 0x31, 0x32, 0x32, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x34, 0x30, 0x31, 0x46, 0x46, 0x32, 0x31, 0x34, + 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x39, + 0x36, 0x34, 0x45, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x37, 0x37, 0x31, 0x34, 0x41, 0x30, 0x33, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x41, 0x31, 0x43, 0x33, 0x31, 0x42, 0x34, + 0x44, 0x34, 0x30, 0x0a, 0x35, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x34, 0x32, 0x32, 0x35, 0x31, 0x37, 0x37, 0x34, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x38, 0x31, 0x43, 0x31, 0x35, + 0x35, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x37, + 0x44, 0x43, 0x33, 0x39, 0x44, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x34, 0x36, 0x34, 0x41, 0x34, 0x42, 0x30, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x45, 0x43, 0x41, 0x43, 0x32, + 0x42, 0x32, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x35, + 0x44, 0x38, 0x46, 0x46, 0x33, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x35, 0x32, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, 0x31, 0x43, + 0x35, 0x44, 0x32, 0x31, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x43, 0x36, 0x42, 0x32, 0x33, 0x39, 0x37, 0x35, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x42, 0x44, 0x33, 0x42, + 0x30, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x39, 0x31, 0x35, + 0x30, 0x35, 0x31, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x32, 0x44, 0x31, 0x32, 0x33, 0x32, 0x34, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x43, 0x33, 0x33, 0x38, 0x45, 0x43, 0x45, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x31, 0x33, 0x32, + 0x34, 0x35, 0x45, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x34, 0x36, 0x39, 0x41, 0x42, 0x30, 0x38, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x44, 0x35, 0x31, 0x38, 0x34, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x42, 0x44, 0x30, + 0x42, 0x32, 0x43, 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x33, 0x34, 0x35, 0x43, 0x39, 0x34, 0x35, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x41, 0x34, 0x41, 0x36, 0x45, 0x31, 0x32, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x34, 0x44, 0x36, + 0x31, 0x45, 0x46, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x34, 0x31, 0x38, 0x41, 0x35, 0x44, 0x39, 0x35, 0x33, 0x34, 0x30, 0x0a, + 0x35, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x32, + 0x36, 0x31, 0x46, 0x37, 0x33, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x45, 0x34, 0x43, 0x45, 0x41, 0x41, 0x34, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x32, 0x32, 0x34, 0x30, + 0x34, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x43, 0x46, + 0x44, 0x36, 0x46, 0x44, 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x33, 0x34, 0x41, 0x37, 0x44, 0x37, 0x33, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x38, 0x35, 0x34, 0x41, + 0x38, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x35, 0x34, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x32, 0x39, 0x44, 0x43, 0x42, 0x43, 0x33, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x43, 0x34, 0x41, + 0x41, 0x34, 0x45, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x35, 0x41, 0x33, 0x42, 0x46, 0x32, 0x34, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x38, 0x33, 0x46, 0x31, 0x41, 0x33, 0x33, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x38, 0x34, 0x44, + 0x43, 0x44, 0x38, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x45, 0x46, 0x46, 0x42, 0x32, 0x44, 0x30, 0x41, 0x34, 0x30, 0x0a, + 0x35, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x44, + 0x30, 0x46, 0x45, 0x45, 0x46, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x30, 0x31, 0x45, 0x30, 0x32, 0x36, 0x43, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x30, 0x45, 0x32, 0x46, 0x42, + 0x43, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x41, 0x33, + 0x42, 0x32, 0x32, 0x38, 0x37, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x38, 0x46, 0x44, 0x33, 0x36, 0x37, 0x30, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x32, 0x37, 0x35, 0x34, + 0x44, 0x31, 0x36, 0x34, 0x30, 0x42, 0x41, 0x41, 0x37, 0x38, 0x33, 0x42, + 0x37, 0x38, 0x38, 0x36, 0x36, 0x35, 0x30, 0x34, 0x30, 0x43, 0x36, 0x39, + 0x41, 0x34, 0x33, 0x39, 0x32, 0x30, 0x33, 0x39, 0x30, 0x32, 0x45, 0x34, + 0x30, 0x0a, 0x35, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x30, 0x41, 0x38, 0x30, 0x34, 0x32, 0x35, 0x34, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, 0x39, 0x45, 0x37, 0x34, 0x34, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x46, 0x45, 0x31, + 0x44, 0x34, 0x46, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x38, 0x38, 0x32, 0x42, 0x32, 0x44, 0x44, 0x33, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x31, 0x41, 0x37, 0x46, 0x35, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, 0x41, 0x33, + 0x42, 0x46, 0x35, 0x31, 0x33, 0x34, 0x30, 0x0a, 0x35, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x38, 0x43, 0x46, 0x44, 0x43, + 0x45, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, + 0x36, 0x32, 0x33, 0x46, 0x33, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x38, 0x32, 0x46, 0x38, 0x38, 0x43, 0x34, 0x33, 0x41, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x44, 0x45, 0x41, 0x35, 0x45, + 0x43, 0x34, 0x35, 0x34, 0x30, 0x36, 0x33, 0x45, 0x42, 0x31, 0x45, 0x42, + 0x34, 0x43, 0x32, 0x31, 0x32, 0x34, 0x39, 0x34, 0x30, 0x36, 0x45, 0x38, + 0x36, 0x44, 0x30, 0x42, 0x41, 0x42, 0x42, 0x45, 0x39, 0x34, 0x43, 0x34, + 0x30, 0x0a, 0x35, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x44, 0x41, 0x38, 0x33, 0x39, 0x37, 0x33, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x38, 0x37, 0x32, 0x41, 0x43, 0x38, 0x45, 0x33, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, 0x30, 0x35, 0x31, + 0x46, 0x34, 0x37, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x38, 0x33, 0x37, 0x45, 0x31, 0x32, 0x41, 0x33, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x43, 0x44, 0x46, 0x41, 0x43, 0x30, 0x37, 0x34, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x33, 0x42, 0x34, + 0x42, 0x32, 0x35, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x43, 0x35, 0x33, 0x33, 0x31, 0x30, 0x45, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x30, 0x44, 0x45, 0x35, 0x44, 0x41, 0x31, 0x33, + 0x30, 0x34, 0x30, 0x45, 0x39, 0x37, 0x39, 0x31, 0x41, 0x39, 0x41, 0x36, + 0x34, 0x35, 0x32, 0x34, 0x31, 0x34, 0x30, 0x43, 0x34, 0x35, 0x36, 0x46, + 0x35, 0x34, 0x42, 0x42, 0x33, 0x36, 0x33, 0x34, 0x32, 0x34, 0x30, 0x0a, + 0x35, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x33, + 0x41, 0x39, 0x31, 0x42, 0x43, 0x33, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x43, 0x35, 0x31, 0x34, 0x37, 0x35, 0x36, 0x34, 0x45, 0x34, + 0x30, 0x42, 0x35, 0x34, 0x34, 0x46, 0x45, 0x35, 0x32, 0x41, 0x46, 0x37, + 0x44, 0x33, 0x43, 0x34, 0x30, 0x44, 0x38, 0x44, 0x37, 0x46, 0x44, 0x31, + 0x39, 0x38, 0x30, 0x42, 0x44, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x36, 0x30, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x36, 0x44, 0x46, + 0x41, 0x46, 0x42, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x33, 0x39, 0x44, 0x45, 0x37, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x35, 0x38, 0x44, 0x36, 0x44, + 0x42, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x32, 0x44, 0x44, + 0x45, 0x32, 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x38, 0x33, 0x39, 0x31, 0x41, 0x39, 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x43, 0x42, 0x36, 0x43, 0x42, 0x37, 0x45, 0x34, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x37, 0x42, 0x39, + 0x36, 0x41, 0x45, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x34, 0x36, 0x38, 0x35, 0x46, 0x46, 0x32, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x38, 0x31, 0x45, 0x37, 0x35, 0x34, 0x33, 0x34, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x34, 0x41, 0x35, + 0x45, 0x36, 0x42, 0x34, 0x33, 0x34, 0x30, 0x0a, 0x36, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x43, 0x31, 0x42, 0x37, 0x45, 0x39, + 0x45, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x33, + 0x36, 0x35, 0x36, 0x38, 0x38, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x30, 0x41, 0x35, 0x45, 0x36, 0x34, 0x42, 0x32, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x32, 0x43, 0x32, 0x38, 0x43, + 0x34, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, + 0x34, 0x44, 0x37, 0x39, 0x32, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x38, 0x42, 0x39, 0x36, 0x37, 0x33, 0x41, 0x34, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x34, 0x42, 0x38, 0x31, 0x43, + 0x44, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x46, + 0x38, 0x38, 0x46, 0x33, 0x38, 0x35, 0x35, 0x34, 0x30, 0x0a, 0x36, 0x32, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x30, 0x38, 0x42, + 0x30, 0x37, 0x35, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x30, 0x31, 0x36, 0x32, 0x30, 0x39, 0x43, 0x33, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x38, 0x37, 0x34, 0x34, 0x36, 0x38, 0x33, 0x33, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x46, 0x33, 0x41, + 0x39, 0x42, 0x33, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x30, 0x45, 0x42, 0x34, 0x38, 0x39, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x34, 0x37, 0x46, 0x44, 0x42, 0x35, 0x34, 0x34, + 0x41, 0x34, 0x30, 0x0a, 0x36, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x36, 0x33, 0x43, 0x31, 0x43, 0x44, 0x33, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x43, 0x37, 0x32, 0x37, + 0x44, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x34, + 0x43, 0x36, 0x46, 0x43, 0x33, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x36, 0x32, 0x43, 0x45, 0x45, 0x31, 0x42, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x33, 0x44, 0x39, 0x46, + 0x32, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, 0x43, + 0x32, 0x32, 0x36, 0x31, 0x41, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x45, 0x38, 0x34, 0x43, 0x34, 0x33, 0x37, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x37, 0x32, 0x39, 0x34, 0x45, + 0x30, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x46, + 0x37, 0x38, 0x31, 0x36, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x30, 0x33, 0x41, 0x36, 0x37, 0x32, 0x31, 0x37, 0x34, + 0x30, 0x0a, 0x36, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x38, 0x34, 0x39, 0x36, 0x33, 0x41, 0x43, 0x34, 0x46, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x45, 0x43, 0x39, 0x33, 0x31, 0x34, + 0x38, 0x34, 0x30, 0x43, 0x38, 0x32, 0x32, 0x39, 0x39, 0x39, 0x37, 0x39, + 0x43, 0x46, 0x37, 0x34, 0x38, 0x34, 0x30, 0x42, 0x30, 0x46, 0x31, 0x42, + 0x43, 0x44, 0x33, 0x30, 0x39, 0x33, 0x38, 0x34, 0x46, 0x34, 0x30, 0x0a, + 0x36, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x36, + 0x43, 0x33, 0x38, 0x38, 0x41, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x42, 0x34, 0x38, 0x32, 0x37, 0x31, 0x34, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x32, 0x37, 0x35, 0x46, 0x35, + 0x39, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x33, + 0x38, 0x38, 0x34, 0x36, 0x46, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x34, 0x31, 0x44, 0x33, 0x42, 0x42, 0x32, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x36, 0x41, 0x42, 0x36, 0x44, + 0x38, 0x32, 0x31, 0x34, 0x30, 0x0a, 0x36, 0x36, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x35, 0x39, 0x36, 0x31, 0x36, 0x38, 0x34, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, 0x39, 0x30, 0x33, + 0x44, 0x35, 0x35, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x38, 0x43, 0x44, 0x37, 0x34, 0x38, 0x42, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x37, 0x44, 0x31, 0x34, 0x35, 0x33, 0x33, + 0x38, 0x34, 0x30, 0x0a, 0x36, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x36, 0x32, 0x44, 0x39, 0x46, 0x30, 0x32, 0x35, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x36, 0x37, 0x38, 0x30, 0x31, + 0x46, 0x32, 0x35, 0x34, 0x30, 0x45, 0x44, 0x37, 0x30, 0x36, 0x44, 0x37, + 0x44, 0x37, 0x34, 0x39, 0x42, 0x34, 0x30, 0x34, 0x30, 0x42, 0x32, 0x46, + 0x38, 0x31, 0x37, 0x34, 0x33, 0x35, 0x33, 0x36, 0x30, 0x33, 0x34, 0x34, + 0x30, 0x0a, 0x36, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x43, 0x42, 0x30, 0x37, 0x37, 0x41, 0x32, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x30, 0x30, 0x39, 0x39, 0x41, 0x42, 0x35, 0x34, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x33, 0x46, 0x42, + 0x39, 0x38, 0x43, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x34, 0x34, 0x32, 0x37, 0x30, 0x35, 0x33, 0x46, 0x34, 0x30, 0x36, + 0x36, 0x31, 0x44, 0x33, 0x32, 0x35, 0x38, 0x32, 0x30, 0x36, 0x30, 0x34, + 0x44, 0x34, 0x30, 0x32, 0x46, 0x35, 0x32, 0x33, 0x39, 0x31, 0x33, 0x45, + 0x46, 0x39, 0x38, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x36, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x44, 0x30, 0x35, 0x42, + 0x39, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x43, 0x35, + 0x42, 0x41, 0x34, 0x43, 0x34, 0x34, 0x46, 0x34, 0x30, 0x35, 0x31, 0x35, + 0x31, 0x44, 0x43, 0x45, 0x45, 0x41, 0x41, 0x44, 0x45, 0x34, 0x31, 0x34, + 0x30, 0x31, 0x46, 0x46, 0x45, 0x33, 0x37, 0x42, 0x37, 0x34, 0x34, 0x31, + 0x45, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x37, 0x30, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x43, 0x37, 0x38, 0x43, 0x46, 0x37, 0x33, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x32, 0x43, 0x37, + 0x33, 0x44, 0x31, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x34, 0x41, 0x36, 0x31, 0x37, 0x30, 0x46, 0x34, 0x44, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x32, 0x37, 0x31, 0x39, 0x43, 0x30, 0x41, 0x35, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x33, 0x38, 0x34, + 0x44, 0x36, 0x42, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x37, 0x32, 0x41, 0x43, 0x46, 0x30, 0x35, 0x38, 0x34, 0x30, 0x0a, + 0x37, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x33, + 0x30, 0x34, 0x32, 0x46, 0x42, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x36, 0x36, 0x42, 0x38, 0x45, 0x31, 0x32, 0x35, 0x37, 0x34, + 0x30, 0x41, 0x34, 0x45, 0x31, 0x32, 0x45, 0x31, 0x30, 0x35, 0x46, 0x44, + 0x36, 0x35, 0x33, 0x34, 0x30, 0x45, 0x43, 0x33, 0x36, 0x39, 0x37, 0x46, + 0x41, 0x34, 0x41, 0x30, 0x33, 0x35, 0x34, 0x34, 0x30, 0x0a, 0x37, 0x32, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x45, 0x34, 0x41, 0x46, + 0x34, 0x42, 0x31, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x30, 0x41, 0x35, 0x35, 0x34, 0x34, 0x44, 0x34, 0x36, 0x34, 0x30, 0x43, + 0x43, 0x42, 0x39, 0x43, 0x44, 0x44, 0x44, 0x33, 0x31, 0x44, 0x33, 0x34, + 0x36, 0x34, 0x30, 0x42, 0x30, 0x38, 0x32, 0x35, 0x38, 0x42, 0x38, 0x30, + 0x39, 0x39, 0x46, 0x33, 0x34, 0x34, 0x30, 0x0a, 0x37, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x43, 0x32, 0x42, 0x45, 0x42, 0x45, + 0x39, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x46, + 0x42, 0x44, 0x34, 0x35, 0x30, 0x32, 0x30, 0x34, 0x30, 0x34, 0x42, 0x43, + 0x34, 0x30, 0x45, 0x34, 0x42, 0x42, 0x31, 0x34, 0x31, 0x34, 0x31, 0x34, + 0x30, 0x42, 0x36, 0x32, 0x45, 0x41, 0x41, 0x36, 0x44, 0x43, 0x41, 0x44, + 0x30, 0x33, 0x41, 0x34, 0x30, 0x0a, 0x37, 0x34, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x32, 0x38, 0x45, 0x46, 0x44, 0x44, 0x33, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x41, 0x30, 0x42, + 0x44, 0x35, 0x33, 0x33, 0x30, 0x34, 0x30, 0x32, 0x39, 0x35, 0x34, 0x41, + 0x41, 0x37, 0x32, 0x43, 0x45, 0x36, 0x44, 0x33, 0x39, 0x34, 0x30, 0x36, + 0x38, 0x37, 0x41, 0x37, 0x37, 0x37, 0x37, 0x44, 0x31, 0x33, 0x44, 0x33, + 0x35, 0x34, 0x30, 0x0a, 0x37, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x45, 0x37, 0x30, 0x33, 0x44, 0x45, 0x33, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, 0x30, 0x39, 0x43, 0x39, 0x37, + 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x45, + 0x32, 0x44, 0x32, 0x46, 0x32, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x31, 0x42, 0x37, 0x31, 0x45, 0x32, 0x34, 0x43, 0x34, + 0x30, 0x31, 0x30, 0x44, 0x32, 0x31, 0x46, 0x33, 0x39, 0x39, 0x32, 0x34, + 0x35, 0x34, 0x42, 0x34, 0x30, 0x33, 0x30, 0x42, 0x38, 0x38, 0x36, 0x43, + 0x36, 0x32, 0x38, 0x32, 0x30, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x37, 0x36, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x36, 0x34, 0x36, + 0x39, 0x42, 0x43, 0x32, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x43, 0x30, 0x38, 0x42, 0x46, 0x32, 0x37, 0x34, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x35, 0x34, 0x41, 0x30, 0x34, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x44, 0x31, 0x32, + 0x36, 0x46, 0x46, 0x34, 0x36, 0x34, 0x30, 0x33, 0x37, 0x36, 0x36, 0x43, + 0x35, 0x44, 0x33, 0x38, 0x33, 0x35, 0x42, 0x34, 0x43, 0x34, 0x30, 0x37, + 0x31, 0x31, 0x42, 0x42, 0x32, 0x34, 0x42, 0x30, 0x32, 0x32, 0x38, 0x34, + 0x43, 0x34, 0x30, 0x0a, 0x37, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x38, 0x33, 0x37, 0x38, 0x46, 0x33, 0x30, 0x33, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x35, 0x32, 0x30, 0x37, 0x37, + 0x35, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x43, + 0x32, 0x46, 0x44, 0x41, 0x33, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x38, 0x30, 0x44, 0x42, 0x31, 0x31, 0x31, 0x34, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x36, 0x32, 0x37, 0x41, 0x30, + 0x45, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x32, + 0x44, 0x45, 0x39, 0x38, 0x45, 0x31, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x33, 0x35, 0x43, 0x31, 0x44, 0x45, 0x30, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x36, 0x39, 0x33, 0x37, 0x41, + 0x35, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, + 0x31, 0x42, 0x32, 0x33, 0x46, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x41, 0x46, 0x37, 0x39, 0x34, 0x39, 0x37, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x39, 0x33, 0x45, 0x35, 0x41, + 0x39, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x42, + 0x39, 0x37, 0x32, 0x34, 0x33, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x36, 0x39, 0x41, 0x36, 0x42, 0x32, 0x33, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x38, 0x33, 0x31, 0x33, 0x37, + 0x38, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x37, 0x38, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x43, 0x30, 0x45, 0x34, 0x34, 0x35, 0x44, 0x35, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x35, 0x31, 0x33, + 0x32, 0x34, 0x43, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x36, 0x33, 0x32, 0x46, 0x33, 0x46, 0x34, 0x46, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x30, 0x42, 0x31, 0x31, 0x33, 0x34, 0x44, 0x31, + 0x46, 0x34, 0x30, 0x0a, 0x37, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x33, 0x45, 0x37, 0x30, 0x44, 0x32, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x43, 0x39, 0x45, + 0x38, 0x34, 0x41, 0x34, 0x30, 0x39, 0x46, 0x43, 0x35, 0x39, 0x44, 0x30, + 0x41, 0x30, 0x37, 0x38, 0x32, 0x34, 0x30, 0x34, 0x30, 0x35, 0x42, 0x39, + 0x36, 0x43, 0x44, 0x33, 0x45, 0x41, 0x39, 0x41, 0x45, 0x35, 0x32, 0x34, + 0x30, 0x0a, 0x38, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x34, 0x41, 0x37, 0x32, 0x45, 0x33, 0x45, 0x34, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x34, 0x46, 0x43, 0x37, 0x36, 0x43, 0x34, 0x34, + 0x46, 0x34, 0x30, 0x34, 0x39, 0x31, 0x44, 0x31, 0x42, 0x38, 0x35, 0x46, + 0x46, 0x36, 0x33, 0x34, 0x41, 0x34, 0x30, 0x41, 0x43, 0x41, 0x41, 0x39, + 0x41, 0x44, 0x43, 0x39, 0x30, 0x41, 0x43, 0x33, 0x38, 0x34, 0x30, 0x0a, + 0x38, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, + 0x37, 0x34, 0x45, 0x33, 0x44, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x34, 0x41, 0x37, 0x41, 0x38, 0x32, 0x43, 0x34, 0x31, 0x34, + 0x30, 0x33, 0x38, 0x33, 0x35, 0x38, 0x38, 0x42, 0x45, 0x45, 0x30, 0x35, + 0x43, 0x35, 0x33, 0x34, 0x30, 0x36, 0x33, 0x44, 0x36, 0x30, 0x39, 0x42, + 0x44, 0x33, 0x32, 0x39, 0x38, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x38, 0x32, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x36, 0x39, 0x32, + 0x35, 0x41, 0x36, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x38, 0x32, 0x38, 0x41, 0x36, 0x30, 0x43, 0x33, 0x42, 0x34, 0x30, 0x36, + 0x30, 0x42, 0x41, 0x34, 0x31, 0x35, 0x41, 0x45, 0x44, 0x42, 0x37, 0x35, + 0x32, 0x34, 0x30, 0x34, 0x39, 0x31, 0x33, 0x36, 0x44, 0x33, 0x38, 0x30, + 0x35, 0x36, 0x30, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x38, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x46, 0x35, 0x35, 0x31, 0x30, + 0x44, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, + 0x44, 0x44, 0x38, 0x42, 0x43, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x36, 0x31, 0x42, 0x45, 0x33, 0x34, 0x43, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x45, 0x45, 0x34, 0x32, 0x34, + 0x37, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x30, 0x32, 0x31, 0x38, 0x39, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x35, 0x41, 0x32, 0x35, 0x45, 0x46, 0x30, 0x33, + 0x46, 0x0a, 0x38, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x34, 0x39, 0x39, 0x45, 0x34, 0x44, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x43, 0x42, 0x45, 0x39, 0x44, 0x41, 0x46, 0x34, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x46, 0x31, 0x37, + 0x44, 0x32, 0x36, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x43, 0x36, 0x37, 0x31, 0x37, 0x43, 0x35, 0x34, 0x37, 0x34, 0x30, 0x0a, + 0x38, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x32, + 0x33, 0x31, 0x43, 0x38, 0x41, 0x31, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x34, 0x34, 0x46, 0x31, 0x38, 0x38, 0x42, 0x34, 0x37, 0x34, + 0x30, 0x35, 0x35, 0x35, 0x37, 0x46, 0x41, 0x38, 0x39, 0x38, 0x43, 0x42, + 0x39, 0x33, 0x34, 0x34, 0x30, 0x35, 0x37, 0x44, 0x44, 0x31, 0x43, 0x31, + 0x38, 0x41, 0x30, 0x31, 0x32, 0x34, 0x45, 0x34, 0x30, 0x0a, 0x38, 0x36, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x46, 0x46, 0x41, + 0x42, 0x33, 0x36, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x45, 0x33, 0x42, 0x36, 0x35, 0x42, 0x43, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x45, 0x45, 0x34, 0x45, 0x41, 0x45, 0x42, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x41, + 0x39, 0x33, 0x45, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x38, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x45, 0x34, 0x32, 0x43, 0x45, 0x45, + 0x33, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x34, + 0x31, 0x34, 0x38, 0x31, 0x35, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x44, 0x38, 0x33, 0x44, 0x41, 0x45, 0x33, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x35, 0x45, 0x42, 0x31, 0x33, + 0x30, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x38, 0x38, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x45, 0x32, 0x30, 0x33, 0x30, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x45, 0x39, 0x32, + 0x42, 0x37, 0x32, 0x35, 0x32, 0x34, 0x30, 0x44, 0x36, 0x30, 0x44, 0x42, + 0x33, 0x36, 0x30, 0x31, 0x31, 0x32, 0x45, 0x34, 0x45, 0x34, 0x30, 0x30, + 0x46, 0x36, 0x42, 0x32, 0x38, 0x35, 0x45, 0x35, 0x46, 0x30, 0x33, 0x35, + 0x32, 0x34, 0x30, 0x0a, 0x38, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x32, 0x37, 0x45, 0x39, 0x39, 0x30, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x43, 0x44, 0x42, 0x45, 0x42, 0x32, + 0x39, 0x34, 0x31, 0x34, 0x30, 0x37, 0x38, 0x35, 0x35, 0x44, 0x46, 0x44, + 0x33, 0x37, 0x33, 0x35, 0x31, 0x33, 0x36, 0x34, 0x30, 0x35, 0x39, 0x45, + 0x35, 0x38, 0x37, 0x35, 0x36, 0x39, 0x33, 0x44, 0x34, 0x34, 0x46, 0x34, + 0x30, 0x0a, 0x39, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x37, 0x31, 0x30, 0x46, 0x31, 0x39, 0x34, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x34, 0x34, 0x37, 0x44, 0x30, 0x45, 0x42, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x46, 0x43, + 0x32, 0x30, 0x45, 0x32, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x38, 0x31, 0x33, 0x44, 0x35, 0x43, 0x39, 0x34, 0x41, 0x34, 0x30, 0x39, + 0x42, 0x37, 0x39, 0x34, 0x34, 0x30, 0x41, 0x39, 0x32, 0x30, 0x46, 0x34, + 0x30, 0x34, 0x30, 0x34, 0x38, 0x33, 0x32, 0x30, 0x35, 0x30, 0x39, 0x38, + 0x41, 0x37, 0x33, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x39, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x37, 0x44, 0x42, 0x43, 0x42, + 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x37, 0x36, 0x42, 0x38, 0x34, 0x45, 0x42, 0x33, 0x46, 0x39, 0x44, 0x35, + 0x30, 0x35, 0x38, 0x33, 0x31, 0x37, 0x38, 0x32, 0x32, 0x35, 0x31, 0x34, + 0x30, 0x38, 0x30, 0x33, 0x37, 0x39, 0x33, 0x42, 0x35, 0x42, 0x37, 0x43, + 0x31, 0x33, 0x46, 0x34, 0x30, 0x0a, 0x39, 0x32, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x30, 0x35, 0x37, 0x36, 0x33, 0x30, 0x36, 0x33, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x46, 0x38, 0x46, + 0x36, 0x39, 0x43, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x43, 0x43, 0x46, 0x31, 0x46, 0x31, 0x38, 0x34, 0x44, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x32, 0x36, 0x31, 0x44, 0x38, 0x38, 0x36, 0x35, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x41, 0x31, 0x30, + 0x32, 0x41, 0x30, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x30, 0x41, 0x37, 0x41, 0x38, 0x39, 0x31, 0x31, 0x34, 0x30, 0x0a, + 0x39, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x46, + 0x39, 0x44, 0x41, 0x45, 0x31, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x38, 0x35, 0x34, 0x30, 0x34, 0x46, 0x42, 0x34, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x41, 0x37, 0x32, 0x42, 0x31, + 0x35, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x34, + 0x45, 0x39, 0x38, 0x38, 0x32, 0x32, 0x31, 0x34, 0x30, 0x33, 0x43, 0x33, + 0x35, 0x39, 0x36, 0x45, 0x43, 0x30, 0x37, 0x30, 0x42, 0x34, 0x44, 0x34, + 0x30, 0x46, 0x43, 0x42, 0x41, 0x37, 0x41, 0x45, 0x42, 0x41, 0x32, 0x30, + 0x32, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x39, 0x34, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x38, 0x37, 0x45, 0x43, 0x35, 0x41, 0x42, 0x34, + 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x37, 0x36, + 0x37, 0x44, 0x43, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x36, 0x46, 0x41, 0x38, 0x33, 0x37, 0x38, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x38, 0x42, 0x44, 0x41, 0x33, 0x33, 0x39, 0x34, + 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x36, 0x45, 0x43, + 0x36, 0x43, 0x43, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x31, 0x45, 0x39, 0x41, 0x34, 0x33, 0x30, 0x46, 0x34, 0x30, 0x43, + 0x45, 0x36, 0x36, 0x33, 0x32, 0x43, 0x39, 0x39, 0x46, 0x43, 0x32, 0x35, + 0x32, 0x34, 0x30, 0x33, 0x36, 0x30, 0x46, 0x42, 0x46, 0x41, 0x31, 0x33, + 0x31, 0x37, 0x35, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x39, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x34, 0x36, 0x30, 0x41, 0x37, + 0x31, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, + 0x32, 0x36, 0x30, 0x30, 0x38, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x30, 0x46, 0x31, 0x37, 0x37, 0x30, 0x34, 0x30, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x36, 0x41, 0x38, 0x30, 0x31, + 0x42, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x31, + 0x41, 0x30, 0x32, 0x33, 0x38, 0x32, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x34, 0x45, 0x41, 0x33, 0x32, 0x43, 0x37, 0x34, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x42, 0x34, 0x30, 0x42, 0x33, + 0x42, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x32, + 0x36, 0x35, 0x30, 0x34, 0x43, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x45, 0x31, 0x31, 0x42, 0x37, 0x36, 0x34, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x32, 0x39, 0x38, 0x30, 0x32, + 0x41, 0x34, 0x35, 0x34, 0x30, 0x0a, 0x39, 0x36, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x33, 0x36, 0x32, 0x35, 0x46, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x35, 0x45, 0x39, + 0x34, 0x37, 0x30, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x30, 0x39, 0x46, 0x42, 0x43, 0x39, 0x43, 0x33, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x38, 0x38, 0x35, 0x38, 0x39, 0x36, 0x41, 0x34, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x36, 0x33, 0x42, + 0x39, 0x39, 0x45, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x30, 0x32, 0x45, 0x33, 0x32, 0x46, 0x42, 0x31, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x42, 0x36, 0x41, 0x32, 0x31, 0x31, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x32, 0x30, 0x32, + 0x33, 0x31, 0x43, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x46, 0x37, 0x46, 0x43, 0x45, 0x32, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x46, 0x45, 0x42, 0x31, 0x45, + 0x45, 0x33, 0x46, 0x0a, 0x39, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x30, 0x33, 0x34, 0x32, 0x39, 0x44, 0x36, 0x32, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, 0x46, 0x39, 0x42, 0x33, 0x43, + 0x38, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x44, + 0x46, 0x31, 0x45, 0x31, 0x37, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x30, 0x32, 0x38, 0x33, 0x30, 0x45, 0x36, 0x31, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x45, 0x46, 0x44, 0x45, 0x33, + 0x35, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x35, 0x41, 0x31, 0x43, 0x44, 0x34, 0x33, 0x46, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x43, 0x36, 0x34, 0x32, 0x44, 0x39, 0x39, 0x34, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x34, 0x45, 0x30, 0x42, 0x39, 0x41, + 0x36, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x37, + 0x37, 0x41, 0x36, 0x32, 0x46, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x44, 0x35, 0x31, 0x42, 0x38, 0x35, 0x35, 0x36, 0x34, + 0x30, 0x0a, 0x39, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x38, 0x46, 0x36, 0x45, 0x44, 0x44, 0x46, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x36, 0x33, 0x46, 0x39, 0x43, 0x41, 0x30, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x44, 0x37, + 0x43, 0x30, 0x35, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x38, 0x35, 0x38, 0x33, 0x39, 0x43, 0x32, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x30, 0x41, 0x41, 0x45, 0x35, 0x45, 0x42, 0x30, + 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x32, 0x39, 0x45, + 0x36, 0x41, 0x38, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x39, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x38, 0x34, 0x33, 0x45, 0x30, + 0x39, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x34, + 0x38, 0x37, 0x44, 0x42, 0x46, 0x32, 0x34, 0x34, 0x30, 0x35, 0x30, 0x33, + 0x44, 0x38, 0x44, 0x36, 0x30, 0x32, 0x38, 0x32, 0x34, 0x34, 0x39, 0x34, + 0x30, 0x35, 0x36, 0x41, 0x42, 0x45, 0x43, 0x44, 0x46, 0x34, 0x45, 0x32, + 0x42, 0x34, 0x30, 0x34, 0x30, 0x0a, 0x31, 0x30, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x41, 0x39, 0x30, 0x37, 0x42, 0x37, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x32, 0x32, + 0x39, 0x34, 0x43, 0x33, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x38, 0x35, 0x45, 0x41, 0x35, 0x36, 0x32, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x30, 0x34, 0x32, 0x34, 0x43, 0x42, + 0x35, 0x38, 0x34, 0x30, 0x42, 0x38, 0x34, 0x41, 0x37, 0x33, 0x37, 0x44, + 0x36, 0x41, 0x42, 0x33, 0x34, 0x37, 0x34, 0x30, 0x45, 0x37, 0x36, 0x37, + 0x44, 0x43, 0x42, 0x42, 0x42, 0x30, 0x33, 0x33, 0x35, 0x35, 0x34, 0x30, + 0x0a, 0x31, 0x30, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x32, 0x46, 0x36, 0x31, 0x46, 0x44, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x45, 0x30, 0x30, 0x43, 0x38, 0x38, 0x35, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x37, 0x31, 0x32, + 0x41, 0x34, 0x35, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x43, 0x35, 0x35, 0x35, 0x32, 0x34, 0x44, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x30, 0x31, 0x45, 0x46, 0x34, 0x31, 0x38, 0x32, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x43, 0x43, 0x32, + 0x45, 0x46, 0x34, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x31, 0x30, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x41, 0x31, 0x35, 0x42, + 0x34, 0x30, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x45, 0x38, 0x33, 0x36, 0x36, 0x32, 0x35, 0x38, 0x34, 0x30, 0x45, 0x38, + 0x36, 0x37, 0x42, 0x36, 0x42, 0x30, 0x33, 0x41, 0x32, 0x42, 0x34, 0x32, + 0x34, 0x30, 0x35, 0x31, 0x42, 0x44, 0x46, 0x41, 0x39, 0x46, 0x45, 0x36, + 0x31, 0x39, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x31, 0x30, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x37, 0x30, 0x35, 0x44, 0x35, + 0x41, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, 0x32, + 0x43, 0x46, 0x32, 0x33, 0x37, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x38, 0x33, 0x41, 0x30, 0x36, 0x36, 0x41, 0x33, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x42, 0x41, 0x30, 0x46, + 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x38, + 0x35, 0x35, 0x30, 0x41, 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x41, 0x33, 0x30, 0x39, 0x34, 0x30, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x36, 0x43, 0x36, 0x38, 0x37, + 0x42, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x45, + 0x43, 0x46, 0x35, 0x44, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x43, 0x44, 0x42, 0x46, 0x33, 0x33, 0x39, 0x35, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, 0x46, 0x30, 0x38, 0x36, 0x44, + 0x45, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x31, 0x30, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x39, 0x34, 0x33, 0x30, 0x46, + 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x34, + 0x39, 0x33, 0x33, 0x34, 0x32, 0x32, 0x34, 0x30, 0x38, 0x32, 0x42, 0x44, + 0x38, 0x36, 0x37, 0x34, 0x35, 0x37, 0x39, 0x44, 0x34, 0x44, 0x34, 0x30, + 0x36, 0x41, 0x44, 0x32, 0x46, 0x34, 0x34, 0x35, 0x39, 0x37, 0x38, 0x37, + 0x32, 0x46, 0x34, 0x30, 0x0a, 0x31, 0x30, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x30, 0x42, 0x36, 0x33, 0x36, 0x35, 0x31, 0x30, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x43, 0x42, 0x46, + 0x36, 0x42, 0x39, 0x35, 0x35, 0x34, 0x30, 0x37, 0x34, 0x39, 0x41, 0x41, + 0x44, 0x42, 0x45, 0x31, 0x35, 0x39, 0x41, 0x32, 0x46, 0x34, 0x30, 0x38, + 0x33, 0x39, 0x44, 0x37, 0x46, 0x41, 0x36, 0x43, 0x31, 0x32, 0x46, 0x33, + 0x43, 0x34, 0x30, 0x0a, 0x31, 0x30, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x42, 0x46, 0x34, 0x38, 0x44, 0x37, 0x32, 0x45, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x30, + 0x36, 0x30, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x41, + 0x38, 0x42, 0x33, 0x38, 0x42, 0x42, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x41, 0x38, 0x31, 0x32, 0x43, 0x45, 0x41, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x38, 0x36, 0x33, + 0x41, 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x44, 0x45, 0x36, 0x34, 0x30, 0x30, 0x33, 0x34, 0x34, 0x30, 0x44, 0x38, + 0x33, 0x33, 0x35, 0x34, 0x32, 0x45, 0x30, 0x46, 0x43, 0x30, 0x35, 0x37, + 0x34, 0x30, 0x44, 0x31, 0x42, 0x44, 0x39, 0x44, 0x34, 0x39, 0x45, 0x33, + 0x43, 0x36, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x31, 0x30, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x45, 0x39, 0x34, 0x31, 0x31, 0x39, + 0x44, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x34, + 0x42, 0x35, 0x32, 0x33, 0x46, 0x31, 0x45, 0x34, 0x30, 0x39, 0x45, 0x30, + 0x30, 0x42, 0x33, 0x42, 0x30, 0x46, 0x41, 0x36, 0x39, 0x34, 0x43, 0x34, + 0x30, 0x36, 0x34, 0x44, 0x44, 0x31, 0x38, 0x38, 0x41, 0x42, 0x31, 0x35, + 0x36, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x31, 0x30, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x39, 0x30, 0x46, 0x42, 0x45, 0x41, + 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x30, 0x35, + 0x30, 0x30, 0x46, 0x45, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x43, 0x33, 0x46, 0x42, 0x45, 0x35, 0x42, 0x34, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x34, 0x34, 0x35, 0x36, 0x44, + 0x35, 0x30, 0x34, 0x30, 0x0a, 0x31, 0x30, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x43, 0x36, 0x46, 0x39, 0x30, 0x31, 0x31, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x30, 0x32, + 0x44, 0x39, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x35, 0x46, 0x31, 0x44, 0x34, 0x42, 0x33, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x32, 0x45, 0x39, 0x45, 0x35, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x43, 0x31, 0x46, + 0x33, 0x45, 0x41, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x31, 0x46, 0x43, 0x31, 0x32, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x36, 0x36, 0x32, 0x33, 0x34, 0x30, 0x33, 0x35, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x38, 0x33, + 0x37, 0x42, 0x30, 0x32, 0x36, 0x34, 0x30, 0x0a, 0x31, 0x31, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x41, 0x44, 0x31, 0x32, + 0x36, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x34, 0x34, 0x33, 0x31, 0x41, 0x39, 0x31, 0x41, 0x34, 0x30, 0x39, 0x44, + 0x45, 0x31, 0x45, 0x37, 0x31, 0x33, 0x32, 0x45, 0x39, 0x37, 0x35, 0x35, + 0x34, 0x30, 0x31, 0x45, 0x33, 0x32, 0x42, 0x37, 0x46, 0x30, 0x41, 0x41, + 0x42, 0x41, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x31, 0x31, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x39, 0x45, 0x36, 0x37, + 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, + 0x35, 0x39, 0x45, 0x38, 0x32, 0x34, 0x45, 0x34, 0x30, 0x45, 0x33, 0x41, + 0x32, 0x39, 0x41, 0x41, 0x35, 0x33, 0x39, 0x43, 0x31, 0x34, 0x46, 0x34, + 0x30, 0x34, 0x43, 0x39, 0x43, 0x38, 0x34, 0x32, 0x35, 0x37, 0x39, 0x43, + 0x42, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x31, 0x31, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x45, 0x31, 0x36, 0x39, 0x31, 0x43, 0x46, + 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x42, 0x39, + 0x35, 0x33, 0x39, 0x45, 0x34, 0x34, 0x34, 0x30, 0x34, 0x31, 0x45, 0x31, + 0x41, 0x45, 0x35, 0x39, 0x45, 0x38, 0x35, 0x35, 0x34, 0x30, 0x34, 0x30, + 0x39, 0x43, 0x34, 0x35, 0x33, 0x42, 0x39, 0x33, 0x35, 0x37, 0x32, 0x31, + 0x32, 0x44, 0x34, 0x30, 0x0a, 0x31, 0x31, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x37, 0x42, 0x34, 0x43, 0x45, 0x46, + 0x32, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x39, 0x37, 0x33, + 0x30, 0x43, 0x30, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x41, 0x30, 0x46, 0x44, 0x45, 0x32, 0x34, 0x35, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x43, 0x35, 0x33, 0x41, 0x36, 0x42, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x42, 0x38, 0x41, + 0x39, 0x38, 0x43, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x34, 0x36, 0x42, 0x43, 0x39, 0x30, 0x46, 0x35, 0x34, 0x34, 0x30, 0x0a, + 0x31, 0x31, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x46, 0x38, 0x45, 0x33, 0x37, 0x45, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x43, 0x35, 0x35, 0x44, 0x32, 0x46, 0x42, 0x34, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x39, 0x44, 0x36, 0x41, + 0x44, 0x38, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x34, 0x46, 0x39, 0x45, 0x41, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x32, 0x34, 0x30, 0x31, 0x32, 0x41, 0x32, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x43, 0x33, 0x34, 0x38, + 0x31, 0x32, 0x32, 0x43, 0x34, 0x30, 0x0a, 0x31, 0x31, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, 0x46, 0x34, 0x36, 0x45, + 0x33, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x45, + 0x42, 0x45, 0x35, 0x41, 0x32, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x34, 0x32, 0x42, 0x39, 0x37, 0x35, 0x42, 0x34, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x35, 0x43, 0x31, + 0x33, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x30, + 0x41, 0x41, 0x38, 0x33, 0x44, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x38, 0x32, 0x30, 0x38, 0x35, 0x36, 0x36, 0x34, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x31, 0x30, 0x31, 0x34, 0x36, + 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, + 0x41, 0x38, 0x42, 0x42, 0x35, 0x30, 0x30, 0x34, 0x30, 0x0a, 0x31, 0x31, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x34, 0x35, + 0x36, 0x30, 0x43, 0x39, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x43, 0x31, 0x33, 0x31, 0x36, 0x30, 0x32, 0x35, 0x30, 0x34, 0x30, + 0x45, 0x41, 0x30, 0x35, 0x45, 0x34, 0x38, 0x31, 0x37, 0x30, 0x41, 0x44, + 0x35, 0x34, 0x34, 0x30, 0x42, 0x30, 0x42, 0x37, 0x37, 0x37, 0x39, 0x43, + 0x38, 0x32, 0x46, 0x32, 0x34, 0x41, 0x34, 0x30, 0x0a, 0x31, 0x31, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x36, 0x46, + 0x32, 0x43, 0x39, 0x31, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x38, 0x41, 0x36, 0x31, 0x43, 0x37, 0x44, 0x33, 0x36, 0x34, 0x30, 0x33, + 0x35, 0x31, 0x39, 0x36, 0x42, 0x41, 0x45, 0x35, 0x32, 0x31, 0x42, 0x33, + 0x30, 0x34, 0x30, 0x42, 0x35, 0x37, 0x39, 0x45, 0x33, 0x34, 0x36, 0x33, + 0x39, 0x42, 0x30, 0x34, 0x33, 0x34, 0x30, 0x0a, 0x31, 0x31, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, 0x43, 0x46, 0x33, 0x34, + 0x46, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x45, + 0x43, 0x31, 0x42, 0x36, 0x39, 0x36, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x39, 0x41, 0x33, 0x39, 0x45, 0x37, 0x33, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x39, 0x32, 0x41, + 0x37, 0x37, 0x34, 0x42, 0x34, 0x30, 0x34, 0x45, 0x31, 0x31, 0x36, 0x44, + 0x36, 0x42, 0x38, 0x36, 0x39, 0x30, 0x33, 0x44, 0x34, 0x30, 0x44, 0x43, + 0x44, 0x42, 0x42, 0x46, 0x46, 0x46, 0x42, 0x44, 0x36, 0x35, 0x34, 0x37, + 0x34, 0x30, 0x0a, 0x31, 0x31, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x43, 0x30, 0x31, 0x43, 0x45, 0x41, 0x44, 0x34, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x41, 0x31, 0x34, 0x38, 0x42, + 0x33, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, + 0x33, 0x45, 0x45, 0x41, 0x30, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x36, 0x46, 0x46, 0x34, 0x34, 0x46, 0x38, 0x35, 0x38, 0x34, + 0x30, 0x43, 0x35, 0x43, 0x37, 0x35, 0x45, 0x30, 0x45, 0x46, 0x45, 0x43, + 0x45, 0x34, 0x32, 0x34, 0x30, 0x43, 0x33, 0x43, 0x44, 0x30, 0x34, 0x44, + 0x31, 0x42, 0x41, 0x30, 0x41, 0x34, 0x42, 0x34, 0x30, 0x0a, 0x31, 0x32, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x34, 0x46, + 0x31, 0x46, 0x41, 0x42, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x30, 0x36, 0x33, 0x30, 0x46, 0x44, 0x36, 0x32, 0x31, 0x34, 0x30, + 0x33, 0x43, 0x33, 0x35, 0x45, 0x45, 0x37, 0x34, 0x32, 0x32, 0x44, 0x38, + 0x34, 0x42, 0x34, 0x30, 0x37, 0x30, 0x38, 0x38, 0x44, 0x31, 0x43, 0x43, + 0x39, 0x39, 0x35, 0x42, 0x34, 0x39, 0x34, 0x30, 0x0a, 0x31, 0x32, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x37, 0x37, + 0x33, 0x31, 0x43, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x38, 0x37, 0x45, 0x37, 0x39, 0x33, 0x38, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x38, 0x31, 0x37, 0x36, 0x38, 0x32, 0x35, 0x33, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x32, 0x34, 0x46, + 0x33, 0x44, 0x34, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x34, 0x35, 0x34, 0x35, 0x33, 0x42, 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x35, 0x45, 0x43, 0x43, 0x43, 0x31, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x34, 0x41, + 0x36, 0x33, 0x36, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x33, 0x35, 0x44, 0x38, 0x37, 0x35, 0x35, 0x32, 0x34, 0x30, 0x0a, + 0x31, 0x32, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, + 0x43, 0x43, 0x34, 0x34, 0x43, 0x37, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x34, 0x46, 0x41, 0x41, 0x41, 0x37, 0x39, 0x34, 0x31, + 0x34, 0x30, 0x46, 0x33, 0x37, 0x41, 0x43, 0x31, 0x41, 0x42, 0x34, 0x37, + 0x35, 0x43, 0x34, 0x42, 0x34, 0x30, 0x31, 0x33, 0x30, 0x46, 0x46, 0x46, + 0x36, 0x33, 0x42, 0x30, 0x42, 0x44, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x31, + 0x32, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x32, + 0x38, 0x44, 0x38, 0x35, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x30, 0x33, 0x33, 0x33, 0x31, 0x45, 0x42, 0x33, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x36, 0x33, 0x32, 0x34, 0x41, + 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x34, 0x37, + 0x35, 0x39, 0x44, 0x31, 0x46, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x31, 0x32, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x41, 0x30, + 0x37, 0x37, 0x43, 0x31, 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x30, 0x36, 0x39, 0x42, 0x34, 0x37, 0x37, 0x34, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x45, 0x35, 0x39, 0x33, 0x42, 0x39, 0x35, + 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x33, 0x31, + 0x34, 0x34, 0x31, 0x35, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x38, 0x32, 0x36, 0x42, 0x36, 0x44, 0x34, 0x33, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x31, 0x38, 0x36, 0x44, 0x38, + 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x45, + 0x41, 0x34, 0x41, 0x30, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x45, 0x41, 0x35, 0x42, 0x42, 0x30, 0x31, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x42, 0x37, 0x44, 0x34, 0x46, 0x45, + 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x33, + 0x31, 0x41, 0x31, 0x31, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x31, 0x32, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, 0x36, 0x34, 0x39, + 0x42, 0x46, 0x35, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x34, 0x33, 0x35, 0x33, 0x35, 0x30, 0x37, 0x34, 0x46, 0x34, 0x30, 0x31, + 0x33, 0x31, 0x34, 0x43, 0x44, 0x35, 0x43, 0x44, 0x37, 0x35, 0x39, 0x35, + 0x32, 0x34, 0x30, 0x44, 0x41, 0x45, 0x37, 0x44, 0x44, 0x42, 0x33, 0x39, + 0x39, 0x39, 0x44, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x31, 0x32, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x38, 0x41, 0x32, 0x38, + 0x43, 0x36, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x32, 0x37, 0x31, 0x34, 0x35, 0x45, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x31, 0x44, 0x44, 0x37, 0x34, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x36, 0x43, 0x36, 0x34, 0x37, + 0x32, 0x41, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, + 0x32, 0x41, 0x44, 0x33, 0x42, 0x35, 0x31, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x41, 0x30, 0x45, 0x35, 0x42, 0x45, 0x36, 0x35, 0x30, + 0x34, 0x30, 0x0a, 0x31, 0x32, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x34, 0x35, 0x35, 0x35, 0x46, 0x30, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x30, 0x42, 0x45, 0x33, 0x39, + 0x31, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x31, + 0x32, 0x43, 0x41, 0x37, 0x43, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x42, 0x42, 0x41, 0x39, 0x30, 0x44, 0x34, 0x38, 0x34, + 0x30, 0x35, 0x42, 0x41, 0x41, 0x33, 0x36, 0x36, 0x42, 0x35, 0x39, 0x42, + 0x45, 0x35, 0x32, 0x34, 0x30, 0x42, 0x39, 0x31, 0x37, 0x34, 0x41, 0x31, + 0x35, 0x46, 0x45, 0x41, 0x42, 0x34, 0x39, 0x34, 0x30, 0x0a, 0x31, 0x32, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x43, 0x32, + 0x30, 0x35, 0x41, 0x37, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x38, 0x38, 0x38, 0x38, 0x44, 0x33, 0x42, 0x33, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x45, 0x37, 0x43, 0x43, 0x38, + 0x46, 0x38, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x42, 0x41, + 0x34, 0x30, 0x35, 0x35, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x41, 0x36, 0x31, 0x44, 0x35, 0x37, 0x32, 0x35, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x38, 0x46, 0x46, 0x38, 0x36, 0x36, + 0x35, 0x36, 0x34, 0x30, 0x0a, 0x31, 0x32, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x32, 0x46, 0x38, 0x41, 0x35, 0x46, 0x44, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x45, 0x34, 0x45, 0x43, + 0x43, 0x42, 0x33, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x43, 0x45, 0x44, 0x37, 0x38, 0x46, 0x39, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x41, 0x36, 0x32, 0x45, 0x42, 0x35, 0x33, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x36, 0x33, 0x31, 0x46, + 0x34, 0x33, 0x46, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x43, 0x36, 0x37, 0x36, 0x39, 0x36, 0x34, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x38, 0x39, 0x45, 0x46, 0x45, 0x44, 0x42, 0x33, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x36, 0x33, 0x42, 0x37, + 0x39, 0x39, 0x37, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x31, 0x33, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x45, 0x34, 0x37, + 0x36, 0x31, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x41, 0x30, 0x39, 0x42, 0x42, 0x35, 0x46, 0x30, 0x33, 0x46, 0x35, 0x46, + 0x43, 0x41, 0x32, 0x43, 0x44, 0x41, 0x46, 0x36, 0x32, 0x38, 0x32, 0x32, + 0x34, 0x30, 0x37, 0x34, 0x38, 0x31, 0x43, 0x31, 0x34, 0x44, 0x43, 0x39, + 0x34, 0x46, 0x34, 0x30, 0x34, 0x30, 0x0a, 0x31, 0x33, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x35, 0x37, 0x38, 0x32, 0x42, + 0x36, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x30, + 0x39, 0x35, 0x38, 0x34, 0x46, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x38, 0x30, 0x38, 0x43, 0x32, 0x44, 0x45, 0x33, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x34, 0x38, 0x34, 0x45, 0x42, + 0x36, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, + 0x43, 0x35, 0x44, 0x46, 0x36, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x30, 0x43, 0x38, 0x32, 0x37, 0x30, 0x44, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x32, 0x46, 0x39, 0x32, 0x37, + 0x43, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x41, + 0x35, 0x46, 0x38, 0x38, 0x33, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x31, 0x33, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x34, 0x45, + 0x38, 0x33, 0x34, 0x41, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x34, 0x39, 0x39, 0x39, 0x32, 0x46, 0x36, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x33, 0x46, 0x30, 0x46, 0x37, 0x37, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x44, 0x35, + 0x33, 0x37, 0x36, 0x34, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x38, 0x45, 0x39, 0x30, 0x38, 0x44, 0x33, 0x33, 0x39, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x34, 0x33, 0x46, 0x35, 0x39, 0x35, + 0x34, 0x44, 0x34, 0x30, 0x0a, 0x31, 0x33, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x36, 0x41, 0x45, 0x36, 0x34, 0x33, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x34, 0x39, 0x46, + 0x41, 0x30, 0x31, 0x35, 0x35, 0x34, 0x30, 0x33, 0x32, 0x32, 0x33, 0x33, + 0x39, 0x30, 0x38, 0x41, 0x30, 0x34, 0x35, 0x34, 0x43, 0x34, 0x30, 0x31, + 0x37, 0x46, 0x42, 0x45, 0x42, 0x30, 0x41, 0x34, 0x41, 0x45, 0x30, 0x35, + 0x31, 0x34, 0x30, 0x0a, 0x31, 0x33, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x38, 0x33, 0x44, 0x38, 0x33, 0x35, 0x42, 0x34, 0x43, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x34, 0x30, 0x36, 0x42, + 0x34, 0x39, 0x34, 0x34, 0x34, 0x30, 0x39, 0x45, 0x42, 0x35, 0x31, 0x44, + 0x37, 0x36, 0x37, 0x38, 0x37, 0x37, 0x34, 0x35, 0x34, 0x30, 0x38, 0x41, + 0x46, 0x36, 0x32, 0x42, 0x41, 0x35, 0x32, 0x30, 0x45, 0x41, 0x34, 0x42, + 0x34, 0x30, 0x0a, 0x31, 0x33, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x38, 0x36, 0x44, 0x37, 0x42, 0x37, 0x34, 0x34, 0x41, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, 0x43, 0x38, 0x44, 0x30, + 0x34, 0x32, 0x35, 0x34, 0x30, 0x46, 0x45, 0x42, 0x31, 0x44, 0x46, 0x41, + 0x36, 0x44, 0x42, 0x32, 0x45, 0x35, 0x30, 0x34, 0x30, 0x35, 0x43, 0x39, + 0x43, 0x39, 0x36, 0x35, 0x45, 0x31, 0x41, 0x43, 0x42, 0x33, 0x41, 0x34, + 0x30, 0x0a, 0x31, 0x33, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x39, 0x32, 0x39, 0x30, 0x44, 0x33, 0x32, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x34, 0x45, 0x39, 0x32, 0x30, 0x43, + 0x34, 0x32, 0x34, 0x30, 0x32, 0x35, 0x36, 0x38, 0x39, 0x31, 0x35, 0x46, + 0x36, 0x30, 0x39, 0x36, 0x33, 0x43, 0x34, 0x30, 0x33, 0x34, 0x46, 0x34, + 0x34, 0x34, 0x33, 0x41, 0x38, 0x42, 0x38, 0x30, 0x34, 0x46, 0x34, 0x30, + 0x0a, 0x31, 0x33, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x38, 0x30, 0x41, 0x32, 0x32, 0x42, 0x32, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x38, 0x35, 0x35, 0x34, 0x38, 0x31, 0x46, 0x34, + 0x41, 0x34, 0x30, 0x37, 0x38, 0x35, 0x45, 0x38, 0x35, 0x33, 0x42, 0x36, + 0x30, 0x38, 0x43, 0x32, 0x45, 0x34, 0x30, 0x42, 0x45, 0x43, 0x39, 0x43, + 0x33, 0x44, 0x33, 0x35, 0x36, 0x32, 0x45, 0x34, 0x45, 0x34, 0x30, 0x0a, + 0x31, 0x33, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, + 0x44, 0x35, 0x36, 0x46, 0x44, 0x37, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x34, 0x44, 0x39, 0x44, 0x36, 0x34, 0x33, 0x35, 0x32, + 0x34, 0x30, 0x45, 0x42, 0x41, 0x37, 0x33, 0x31, 0x37, 0x39, 0x46, 0x31, + 0x32, 0x36, 0x35, 0x31, 0x34, 0x30, 0x33, 0x42, 0x31, 0x34, 0x45, 0x33, + 0x33, 0x39, 0x41, 0x42, 0x45, 0x34, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x31, + 0x33, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x45, 0x41, + 0x46, 0x38, 0x36, 0x44, 0x45, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x45, 0x31, 0x35, 0x34, 0x43, 0x31, 0x32, 0x35, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, 0x38, 0x39, 0x30, 0x42, + 0x30, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x46, + 0x46, 0x46, 0x41, 0x45, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x38, 0x38, 0x30, 0x45, 0x30, 0x34, 0x33, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x32, 0x42, 0x37, 0x30, 0x39, + 0x42, 0x34, 0x39, 0x34, 0x30, 0x42, 0x45, 0x33, 0x42, 0x31, 0x32, 0x41, + 0x32, 0x41, 0x45, 0x34, 0x34, 0x34, 0x36, 0x34, 0x30, 0x43, 0x35, 0x46, + 0x39, 0x46, 0x46, 0x33, 0x31, 0x36, 0x41, 0x38, 0x34, 0x34, 0x34, 0x34, + 0x30, 0x0a, 0x31, 0x34, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x32, 0x43, 0x34, 0x32, 0x35, 0x45, 0x42, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x41, 0x32, 0x32, 0x45, 0x30, 0x42, 0x45, + 0x35, 0x30, 0x34, 0x30, 0x36, 0x35, 0x37, 0x31, 0x44, 0x38, 0x42, 0x46, + 0x41, 0x42, 0x36, 0x43, 0x35, 0x35, 0x34, 0x30, 0x46, 0x30, 0x38, 0x30, + 0x43, 0x32, 0x33, 0x35, 0x43, 0x38, 0x44, 0x33, 0x35, 0x30, 0x34, 0x30, + 0x0a, 0x31, 0x34, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x38, 0x38, 0x43, 0x32, 0x33, 0x34, 0x42, 0x33, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x31, 0x43, 0x31, 0x43, 0x42, 0x32, + 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x45, 0x39, 0x39, + 0x34, 0x33, 0x31, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x44, 0x32, 0x45, 0x42, 0x36, 0x43, 0x34, 0x46, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x43, 0x37, 0x39, 0x41, 0x45, 0x33, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x44, 0x39, 0x42, + 0x36, 0x35, 0x38, 0x32, 0x45, 0x34, 0x30, 0x0a, 0x31, 0x34, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, 0x35, 0x39, 0x32, + 0x31, 0x36, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, + 0x38, 0x32, 0x35, 0x46, 0x38, 0x34, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x38, 0x36, 0x36, 0x33, 0x31, 0x34, 0x30, 0x35, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x34, 0x36, 0x46, 0x37, + 0x46, 0x35, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, + 0x37, 0x44, 0x42, 0x38, 0x39, 0x30, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, 0x34, 0x45, 0x46, 0x35, 0x37, + 0x34, 0x30, 0x0a, 0x31, 0x34, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x32, 0x43, 0x33, 0x45, 0x44, 0x45, 0x37, 0x35, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x46, 0x44, 0x34, 0x45, + 0x45, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, + 0x35, 0x39, 0x43, 0x35, 0x32, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x43, 0x45, 0x35, 0x43, 0x44, 0x41, 0x36, 0x35, 0x30, 0x34, + 0x30, 0x0a, 0x31, 0x34, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x31, 0x38, 0x42, 0x36, 0x34, 0x32, 0x35, 0x34, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x46, 0x41, 0x42, 0x37, 0x44, 0x38, + 0x32, 0x42, 0x34, 0x30, 0x31, 0x33, 0x43, 0x36, 0x31, 0x42, 0x34, 0x45, + 0x38, 0x32, 0x33, 0x41, 0x34, 0x45, 0x34, 0x30, 0x42, 0x39, 0x42, 0x34, + 0x31, 0x45, 0x33, 0x44, 0x37, 0x30, 0x46, 0x32, 0x32, 0x38, 0x34, 0x30, + 0x0a, 0x31, 0x34, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x34, 0x34, 0x35, 0x34, 0x42, 0x45, 0x43, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x38, 0x34, 0x38, 0x38, 0x44, + 0x30, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x38, 0x36, 0x46, + 0x44, 0x44, 0x34, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x34, 0x30, 0x44, 0x46, 0x36, 0x35, 0x43, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x41, 0x42, 0x39, 0x35, 0x30, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x32, 0x46, + 0x32, 0x39, 0x46, 0x34, 0x34, 0x34, 0x30, 0x45, 0x36, 0x35, 0x35, 0x45, + 0x46, 0x38, 0x43, 0x32, 0x38, 0x36, 0x38, 0x34, 0x33, 0x34, 0x30, 0x42, + 0x46, 0x38, 0x39, 0x34, 0x45, 0x43, 0x43, 0x45, 0x43, 0x36, 0x46, 0x34, + 0x43, 0x34, 0x30, 0x0a, 0x31, 0x34, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x32, 0x46, 0x30, 0x35, 0x44, 0x30, 0x34, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x33, 0x33, 0x44, 0x37, + 0x43, 0x39, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x32, 0x37, 0x32, 0x39, 0x37, 0x36, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x43, 0x38, 0x37, 0x38, 0x41, 0x45, 0x37, 0x34, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x42, 0x39, 0x32, 0x37, + 0x39, 0x32, 0x33, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x42, 0x34, 0x42, 0x36, 0x36, 0x30, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x31, + 0x34, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x45, + 0x35, 0x43, 0x44, 0x44, 0x32, 0x34, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x43, 0x32, 0x34, 0x30, 0x36, 0x45, 0x37, 0x34, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x35, 0x43, 0x33, 0x32, 0x30, + 0x39, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x43, + 0x31, 0x37, 0x33, 0x34, 0x39, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x43, 0x41, 0x37, 0x44, 0x42, 0x36, 0x33, 0x34, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x43, 0x45, 0x39, 0x31, 0x43, + 0x33, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x43, + 0x41, 0x38, 0x34, 0x36, 0x41, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x42, 0x33, 0x44, 0x36, 0x30, 0x44, 0x34, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x37, 0x41, 0x35, 0x46, 0x31, + 0x46, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, + 0x31, 0x43, 0x35, 0x35, 0x46, 0x31, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x38, 0x33, 0x45, 0x34, 0x35, 0x36, 0x35, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x46, 0x45, 0x39, 0x32, 0x44, + 0x45, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x31, 0x34, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x42, 0x31, 0x32, 0x44, 0x31, 0x38, + 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x39, + 0x44, 0x31, 0x31, 0x36, 0x33, 0x32, 0x34, 0x30, 0x45, 0x43, 0x46, 0x45, + 0x41, 0x44, 0x36, 0x30, 0x39, 0x30, 0x37, 0x38, 0x34, 0x33, 0x34, 0x30, + 0x41, 0x36, 0x34, 0x33, 0x35, 0x46, 0x42, 0x39, 0x45, 0x31, 0x31, 0x34, + 0x33, 0x42, 0x34, 0x30, 0x0a, 0x31, 0x34, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x38, 0x35, 0x36, 0x43, 0x42, 0x30, 0x33, 0x34, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x35, 0x34, 0x35, + 0x39, 0x43, 0x41, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x43, 0x42, 0x43, 0x45, 0x30, 0x36, 0x45, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x30, 0x45, 0x30, 0x43, 0x39, 0x42, 0x34, 0x31, + 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x43, 0x44, 0x42, + 0x38, 0x37, 0x42, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x35, 0x33, 0x43, 0x46, 0x39, 0x42, 0x32, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x46, 0x44, 0x30, 0x43, 0x32, 0x30, 0x34, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x33, 0x41, 0x43, + 0x41, 0x36, 0x46, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x31, 0x35, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x45, 0x34, 0x34, 0x38, + 0x34, 0x35, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x41, 0x32, 0x41, 0x43, 0x42, 0x35, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x43, 0x35, 0x45, 0x45, 0x31, 0x44, 0x32, 0x43, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, 0x33, 0x34, 0x34, 0x35, + 0x43, 0x42, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x45, + 0x31, 0x37, 0x39, 0x41, 0x43, 0x44, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x42, 0x42, 0x38, 0x36, 0x31, 0x32, 0x32, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x30, 0x31, 0x46, 0x46, + 0x32, 0x31, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x39, 0x36, 0x34, 0x45, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x37, 0x37, 0x31, 0x34, 0x41, 0x30, 0x33, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x41, 0x31, 0x43, 0x33, + 0x31, 0x42, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x31, 0x35, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x32, 0x32, 0x35, 0x31, 0x37, + 0x37, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x38, + 0x31, 0x43, 0x31, 0x35, 0x35, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x30, 0x37, 0x44, 0x43, 0x33, 0x39, 0x44, 0x34, 0x46, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x36, 0x34, 0x41, 0x34, 0x42, + 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x45, + 0x43, 0x41, 0x43, 0x32, 0x42, 0x32, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x34, 0x35, 0x44, 0x38, 0x46, 0x46, 0x33, 0x34, 0x46, 0x34, + 0x30, 0x0a, 0x31, 0x35, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x31, 0x31, 0x43, 0x35, 0x44, 0x32, 0x31, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x44, 0x43, 0x36, 0x42, 0x32, 0x33, 0x39, 0x37, + 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, + 0x37, 0x42, 0x44, 0x33, 0x42, 0x30, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x43, 0x39, 0x31, 0x35, 0x30, 0x35, 0x31, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x32, 0x44, 0x31, 0x32, 0x33, 0x32, + 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x33, 0x33, + 0x38, 0x45, 0x43, 0x45, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x38, 0x31, 0x33, 0x32, 0x34, 0x35, 0x45, 0x33, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x36, 0x39, 0x41, 0x42, 0x30, 0x38, + 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, + 0x44, 0x35, 0x31, 0x38, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x38, 0x42, 0x44, 0x30, 0x42, 0x32, 0x43, 0x33, 0x45, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x34, 0x35, 0x43, 0x39, 0x34, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x41, 0x34, + 0x41, 0x36, 0x45, 0x31, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x45, 0x34, 0x44, 0x36, 0x31, 0x45, 0x46, 0x35, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x31, 0x38, 0x41, 0x35, 0x44, 0x39, + 0x35, 0x33, 0x34, 0x30, 0x0a, 0x31, 0x35, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x32, 0x36, 0x31, 0x46, 0x37, 0x33, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x45, 0x34, 0x43, 0x45, + 0x41, 0x41, 0x34, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x32, 0x32, 0x34, 0x30, 0x34, 0x32, 0x45, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x43, 0x46, 0x44, 0x36, 0x46, 0x44, 0x35, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x34, 0x41, + 0x37, 0x44, 0x37, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x30, 0x30, 0x38, 0x35, 0x34, 0x41, 0x38, 0x34, 0x32, 0x34, 0x30, 0x0a, + 0x31, 0x35, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x32, + 0x39, 0x44, 0x43, 0x42, 0x43, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x38, 0x43, 0x34, 0x41, 0x41, 0x34, 0x45, 0x34, 0x43, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x35, 0x41, 0x33, 0x42, + 0x46, 0x32, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, + 0x33, 0x46, 0x31, 0x41, 0x33, 0x33, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x30, 0x38, 0x34, 0x44, 0x43, 0x44, 0x38, 0x33, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x45, 0x46, 0x46, 0x42, + 0x32, 0x44, 0x30, 0x41, 0x34, 0x30, 0x0a, 0x31, 0x35, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x44, 0x30, 0x46, 0x45, 0x45, + 0x46, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x31, + 0x45, 0x30, 0x32, 0x36, 0x43, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x34, 0x30, 0x45, 0x32, 0x46, 0x42, 0x43, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x41, 0x33, 0x42, 0x32, 0x32, 0x38, + 0x37, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x46, + 0x44, 0x33, 0x36, 0x37, 0x30, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x37, 0x32, 0x37, 0x35, 0x34, 0x44, 0x31, 0x36, 0x34, + 0x30, 0x42, 0x41, 0x41, 0x37, 0x38, 0x33, 0x42, 0x37, 0x38, 0x38, 0x36, + 0x36, 0x35, 0x30, 0x34, 0x30, 0x43, 0x36, 0x39, 0x41, 0x34, 0x33, 0x39, + 0x32, 0x30, 0x33, 0x39, 0x30, 0x32, 0x45, 0x34, 0x30, 0x0a, 0x31, 0x35, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, 0x38, + 0x30, 0x34, 0x32, 0x35, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x31, 0x30, 0x39, 0x45, 0x37, 0x34, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x46, 0x45, 0x31, 0x44, 0x34, 0x46, + 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x38, 0x32, + 0x42, 0x32, 0x44, 0x44, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x30, 0x31, 0x31, 0x41, 0x37, 0x46, 0x35, 0x34, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, 0x41, 0x33, 0x42, 0x46, 0x35, + 0x31, 0x33, 0x34, 0x30, 0x0a, 0x31, 0x35, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x30, 0x38, 0x43, 0x46, 0x44, 0x43, 0x45, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x36, 0x32, + 0x33, 0x46, 0x33, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x38, 0x32, 0x46, 0x38, 0x38, 0x43, 0x34, 0x33, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x38, 0x44, 0x45, 0x41, 0x35, 0x45, 0x43, 0x34, + 0x35, 0x34, 0x30, 0x36, 0x33, 0x45, 0x42, 0x31, 0x45, 0x42, 0x34, 0x43, + 0x32, 0x31, 0x32, 0x34, 0x39, 0x34, 0x30, 0x36, 0x45, 0x38, 0x36, 0x44, + 0x30, 0x42, 0x41, 0x42, 0x42, 0x45, 0x39, 0x34, 0x43, 0x34, 0x30, 0x0a, + 0x31, 0x35, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x44, 0x41, 0x38, 0x33, 0x39, 0x37, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x37, 0x32, 0x41, 0x43, 0x38, 0x45, 0x33, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, 0x30, 0x35, 0x31, 0x46, + 0x34, 0x37, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, + 0x33, 0x37, 0x45, 0x31, 0x32, 0x41, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x43, 0x44, 0x46, 0x41, 0x43, 0x30, 0x37, 0x34, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x33, 0x42, 0x34, 0x42, + 0x32, 0x35, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, + 0x35, 0x33, 0x33, 0x31, 0x30, 0x45, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x30, 0x44, 0x45, 0x35, 0x44, 0x41, 0x31, 0x33, 0x30, + 0x34, 0x30, 0x45, 0x39, 0x37, 0x39, 0x31, 0x41, 0x39, 0x41, 0x36, 0x34, + 0x35, 0x32, 0x34, 0x31, 0x34, 0x30, 0x43, 0x34, 0x35, 0x36, 0x46, 0x35, + 0x34, 0x42, 0x42, 0x33, 0x36, 0x33, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x31, + 0x35, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x33, + 0x41, 0x39, 0x31, 0x42, 0x43, 0x33, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x43, 0x35, 0x31, 0x34, 0x37, 0x35, 0x36, 0x34, 0x45, 0x34, + 0x30, 0x42, 0x35, 0x34, 0x34, 0x46, 0x45, 0x35, 0x32, 0x41, 0x46, 0x37, + 0x44, 0x33, 0x43, 0x34, 0x30, 0x44, 0x38, 0x44, 0x37, 0x46, 0x44, 0x31, + 0x39, 0x38, 0x30, 0x42, 0x44, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x31, 0x36, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x36, 0x44, + 0x46, 0x41, 0x46, 0x42, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x33, 0x39, 0x44, 0x45, 0x37, 0x30, 0x34, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x35, 0x38, 0x44, 0x36, + 0x44, 0x42, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x32, 0x44, + 0x44, 0x45, 0x32, 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x38, 0x33, 0x39, 0x31, 0x41, 0x39, 0x43, 0x35, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x42, 0x36, 0x43, 0x42, 0x37, 0x45, + 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x37, 0x42, + 0x39, 0x36, 0x41, 0x45, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x30, 0x34, 0x36, 0x38, 0x35, 0x46, 0x46, 0x32, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x31, 0x45, 0x37, 0x35, 0x34, 0x33, + 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x34, 0x41, + 0x35, 0x45, 0x36, 0x42, 0x34, 0x33, 0x34, 0x30, 0x0a, 0x31, 0x36, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x43, 0x31, 0x42, 0x37, + 0x45, 0x39, 0x45, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x38, 0x33, 0x36, 0x35, 0x36, 0x38, 0x38, 0x34, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x30, 0x41, 0x35, 0x45, 0x36, 0x34, 0x42, 0x32, + 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x32, 0x43, 0x32, + 0x38, 0x43, 0x34, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x35, 0x34, 0x44, 0x37, 0x39, 0x32, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x38, 0x42, 0x39, 0x36, 0x37, 0x33, 0x41, 0x34, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x34, 0x42, 0x38, + 0x31, 0x43, 0x44, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x43, 0x46, 0x38, 0x38, 0x46, 0x33, 0x38, 0x35, 0x35, 0x34, 0x30, 0x0a, + 0x31, 0x36, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, + 0x30, 0x38, 0x42, 0x30, 0x37, 0x35, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x31, 0x36, 0x32, 0x30, 0x39, 0x43, 0x33, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x37, 0x34, 0x34, 0x36, + 0x38, 0x33, 0x33, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, + 0x46, 0x33, 0x41, 0x39, 0x42, 0x33, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x45, 0x42, 0x34, 0x38, 0x39, 0x32, 0x35, 0x34, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x34, 0x37, 0x46, 0x44, 0x42, + 0x35, 0x34, 0x34, 0x41, 0x34, 0x30, 0x0a, 0x31, 0x36, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x33, 0x43, 0x31, 0x43, + 0x44, 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, + 0x43, 0x37, 0x32, 0x37, 0x44, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x34, 0x43, 0x36, 0x46, 0x43, 0x33, 0x34, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x32, 0x43, 0x45, 0x45, 0x31, + 0x42, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, + 0x33, 0x44, 0x39, 0x46, 0x32, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x43, 0x43, 0x32, 0x32, 0x36, 0x31, 0x41, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x38, 0x34, 0x43, 0x34, 0x33, + 0x37, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x37, + 0x32, 0x39, 0x34, 0x45, 0x30, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x43, 0x46, 0x37, 0x38, 0x31, 0x36, 0x43, 0x34, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x33, 0x41, 0x36, 0x37, + 0x32, 0x31, 0x37, 0x34, 0x30, 0x0a, 0x31, 0x36, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x34, 0x39, 0x36, 0x33, 0x41, 0x43, + 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x45, + 0x43, 0x39, 0x33, 0x31, 0x34, 0x38, 0x34, 0x30, 0x43, 0x38, 0x32, 0x32, + 0x39, 0x39, 0x39, 0x37, 0x39, 0x43, 0x46, 0x37, 0x34, 0x38, 0x34, 0x30, + 0x42, 0x30, 0x46, 0x31, 0x42, 0x43, 0x44, 0x33, 0x30, 0x39, 0x33, 0x38, + 0x34, 0x46, 0x34, 0x30, 0x0a, 0x31, 0x36, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x30, 0x36, 0x43, 0x33, 0x38, 0x38, 0x41, 0x30, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x42, 0x34, 0x38, + 0x32, 0x37, 0x31, 0x34, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x36, 0x32, 0x37, 0x35, 0x46, 0x35, 0x39, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x33, 0x38, 0x38, 0x34, 0x36, 0x46, 0x34, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x34, 0x31, 0x44, + 0x33, 0x42, 0x42, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x36, 0x41, 0x42, 0x36, 0x44, 0x38, 0x32, 0x31, 0x34, 0x30, 0x0a, + 0x31, 0x36, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x35, 0x39, 0x36, 0x31, 0x36, 0x38, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x41, 0x39, 0x30, 0x33, 0x44, 0x35, 0x35, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x43, 0x44, 0x37, 0x34, + 0x38, 0x42, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x37, 0x44, 0x31, 0x34, 0x35, 0x33, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x31, + 0x36, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x32, + 0x44, 0x39, 0x46, 0x30, 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x36, 0x37, 0x38, 0x30, 0x31, 0x46, 0x32, 0x35, 0x34, + 0x30, 0x45, 0x44, 0x37, 0x30, 0x36, 0x44, 0x37, 0x44, 0x37, 0x34, 0x39, + 0x42, 0x34, 0x30, 0x34, 0x30, 0x42, 0x32, 0x46, 0x38, 0x31, 0x37, 0x34, + 0x33, 0x35, 0x33, 0x36, 0x30, 0x33, 0x34, 0x34, 0x30, 0x0a, 0x31, 0x36, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x43, 0x42, + 0x30, 0x37, 0x37, 0x41, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x30, 0x30, 0x39, 0x39, 0x41, 0x42, 0x35, 0x34, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x33, 0x46, 0x42, 0x39, 0x38, 0x43, + 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x34, + 0x32, 0x37, 0x30, 0x35, 0x33, 0x46, 0x34, 0x30, 0x36, 0x36, 0x31, 0x44, + 0x33, 0x32, 0x35, 0x38, 0x32, 0x30, 0x36, 0x30, 0x34, 0x44, 0x34, 0x30, + 0x32, 0x46, 0x35, 0x32, 0x33, 0x39, 0x31, 0x33, 0x45, 0x46, 0x39, 0x38, + 0x35, 0x30, 0x34, 0x30, 0x0a, 0x31, 0x36, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x44, 0x30, 0x35, 0x42, 0x39, 0x34, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x43, 0x35, 0x42, 0x41, + 0x34, 0x43, 0x34, 0x34, 0x46, 0x34, 0x30, 0x35, 0x31, 0x35, 0x31, 0x44, + 0x43, 0x45, 0x45, 0x41, 0x41, 0x44, 0x45, 0x34, 0x31, 0x34, 0x30, 0x31, + 0x46, 0x46, 0x45, 0x33, 0x37, 0x42, 0x37, 0x34, 0x34, 0x31, 0x45, 0x34, + 0x44, 0x34, 0x30, 0x0a, 0x31, 0x37, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x43, 0x37, 0x38, 0x43, 0x46, 0x37, 0x33, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x32, 0x43, 0x37, 0x33, + 0x44, 0x31, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, + 0x41, 0x36, 0x31, 0x37, 0x30, 0x46, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x32, 0x37, 0x31, 0x39, 0x43, 0x30, 0x41, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x33, 0x38, 0x34, 0x44, + 0x36, 0x42, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x37, 0x32, 0x41, 0x43, 0x46, 0x30, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x31, + 0x37, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x33, + 0x30, 0x34, 0x32, 0x46, 0x42, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x36, 0x36, 0x42, 0x38, 0x45, 0x31, 0x32, 0x35, 0x37, 0x34, + 0x30, 0x41, 0x34, 0x45, 0x31, 0x32, 0x45, 0x31, 0x30, 0x35, 0x46, 0x44, + 0x36, 0x35, 0x33, 0x34, 0x30, 0x45, 0x43, 0x33, 0x36, 0x39, 0x37, 0x46, + 0x41, 0x34, 0x41, 0x30, 0x33, 0x35, 0x34, 0x34, 0x30, 0x0a, 0x31, 0x37, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x45, 0x34, 0x41, + 0x46, 0x34, 0x42, 0x31, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x41, 0x35, 0x35, 0x34, 0x34, 0x44, 0x34, 0x36, 0x34, 0x30, + 0x43, 0x43, 0x42, 0x39, 0x43, 0x44, 0x44, 0x44, 0x33, 0x31, 0x44, 0x33, + 0x34, 0x36, 0x34, 0x30, 0x42, 0x30, 0x38, 0x32, 0x35, 0x38, 0x42, 0x38, + 0x30, 0x39, 0x39, 0x46, 0x33, 0x34, 0x34, 0x30, 0x0a, 0x31, 0x37, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x43, 0x32, 0x42, 0x45, + 0x42, 0x45, 0x39, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x30, 0x46, 0x42, 0x44, 0x34, 0x35, 0x30, 0x32, 0x30, 0x34, 0x30, 0x34, + 0x42, 0x43, 0x34, 0x30, 0x45, 0x34, 0x42, 0x42, 0x31, 0x34, 0x31, 0x34, + 0x31, 0x34, 0x30, 0x42, 0x36, 0x32, 0x45, 0x41, 0x41, 0x36, 0x44, 0x43, + 0x41, 0x44, 0x30, 0x33, 0x41, 0x34, 0x30, 0x0a, 0x31, 0x37, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x32, 0x38, 0x45, 0x46, + 0x44, 0x44, 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, + 0x41, 0x30, 0x42, 0x44, 0x35, 0x33, 0x33, 0x30, 0x34, 0x30, 0x32, 0x39, + 0x35, 0x34, 0x41, 0x41, 0x37, 0x32, 0x43, 0x45, 0x36, 0x44, 0x33, 0x39, + 0x34, 0x30, 0x36, 0x38, 0x37, 0x41, 0x37, 0x37, 0x37, 0x37, 0x44, 0x31, + 0x33, 0x44, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x31, 0x37, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x45, 0x37, 0x30, 0x33, 0x44, + 0x45, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, 0x30, + 0x39, 0x43, 0x39, 0x37, 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x45, 0x32, 0x44, 0x32, 0x46, 0x32, 0x33, 0x46, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x42, 0x37, 0x31, 0x45, + 0x32, 0x34, 0x43, 0x34, 0x30, 0x31, 0x30, 0x44, 0x32, 0x31, 0x46, 0x33, + 0x39, 0x39, 0x32, 0x34, 0x35, 0x34, 0x42, 0x34, 0x30, 0x33, 0x30, 0x42, + 0x38, 0x38, 0x36, 0x43, 0x36, 0x32, 0x38, 0x32, 0x30, 0x34, 0x43, 0x34, + 0x30, 0x0a, 0x31, 0x37, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x36, 0x34, 0x36, 0x39, 0x42, 0x43, 0x32, 0x34, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x30, 0x38, 0x42, 0x46, 0x32, 0x37, + 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x35, + 0x34, 0x41, 0x30, 0x34, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x43, 0x44, 0x31, 0x32, 0x36, 0x46, 0x46, 0x34, 0x36, 0x34, 0x30, + 0x33, 0x37, 0x36, 0x36, 0x43, 0x35, 0x44, 0x33, 0x38, 0x33, 0x35, 0x42, + 0x34, 0x43, 0x34, 0x30, 0x37, 0x31, 0x31, 0x42, 0x42, 0x32, 0x34, 0x42, + 0x30, 0x32, 0x32, 0x38, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x31, 0x37, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x33, 0x37, 0x38, + 0x46, 0x33, 0x30, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x38, 0x35, 0x32, 0x30, 0x37, 0x37, 0x35, 0x33, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x34, 0x43, 0x32, 0x46, 0x44, 0x41, 0x33, 0x34, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x44, 0x42, + 0x31, 0x31, 0x31, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x36, 0x36, 0x32, 0x37, 0x41, 0x30, 0x45, 0x35, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x32, 0x44, 0x45, 0x39, 0x38, 0x45, 0x31, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x35, 0x43, + 0x31, 0x44, 0x45, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x36, 0x39, 0x33, 0x37, 0x41, 0x35, 0x33, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x31, 0x42, 0x32, 0x33, 0x46, 0x30, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x41, 0x46, 0x37, 0x39, + 0x34, 0x39, 0x37, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x30, 0x39, 0x33, 0x45, 0x35, 0x41, 0x39, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x42, 0x39, 0x37, 0x32, 0x34, 0x33, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x39, 0x41, + 0x36, 0x42, 0x32, 0x33, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x43, 0x38, 0x33, 0x31, 0x33, 0x37, 0x38, 0x35, 0x38, 0x34, 0x30, 0x0a, + 0x31, 0x37, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, + 0x30, 0x45, 0x34, 0x34, 0x35, 0x44, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x34, 0x35, 0x31, 0x33, 0x32, 0x34, 0x43, 0x34, 0x32, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x36, 0x33, 0x32, 0x46, + 0x33, 0x46, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x42, 0x31, 0x31, 0x33, 0x34, 0x44, 0x31, 0x46, 0x34, 0x30, 0x0a, 0x31, + 0x37, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x33, 0x45, 0x37, 0x30, 0x44, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x38, 0x34, 0x38, 0x43, 0x39, 0x45, 0x38, 0x34, 0x41, 0x34, + 0x30, 0x39, 0x46, 0x43, 0x35, 0x39, 0x44, 0x30, 0x41, 0x30, 0x37, 0x38, + 0x32, 0x34, 0x30, 0x34, 0x30, 0x35, 0x42, 0x39, 0x36, 0x43, 0x44, 0x33, + 0x45, 0x41, 0x39, 0x41, 0x45, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x31, 0x38, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x41, 0x37, + 0x32, 0x45, 0x33, 0x45, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x34, 0x46, 0x43, 0x37, 0x36, 0x43, 0x34, 0x34, 0x46, 0x34, 0x30, + 0x34, 0x39, 0x31, 0x44, 0x31, 0x42, 0x38, 0x35, 0x46, 0x46, 0x36, 0x33, + 0x34, 0x41, 0x34, 0x30, 0x41, 0x43, 0x41, 0x41, 0x39, 0x41, 0x44, 0x43, + 0x39, 0x30, 0x41, 0x43, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x31, 0x38, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x37, 0x34, + 0x45, 0x33, 0x44, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x34, 0x41, 0x37, 0x41, 0x38, 0x32, 0x43, 0x34, 0x31, 0x34, 0x30, 0x33, + 0x38, 0x33, 0x35, 0x38, 0x38, 0x42, 0x45, 0x45, 0x30, 0x35, 0x43, 0x35, + 0x33, 0x34, 0x30, 0x36, 0x33, 0x44, 0x36, 0x30, 0x39, 0x42, 0x44, 0x33, + 0x32, 0x39, 0x38, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x31, 0x38, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x36, 0x39, 0x32, 0x35, + 0x41, 0x36, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, + 0x32, 0x38, 0x41, 0x36, 0x30, 0x43, 0x33, 0x42, 0x34, 0x30, 0x36, 0x30, + 0x42, 0x41, 0x34, 0x31, 0x35, 0x41, 0x45, 0x44, 0x42, 0x37, 0x35, 0x32, + 0x34, 0x30, 0x34, 0x39, 0x31, 0x33, 0x36, 0x44, 0x33, 0x38, 0x30, 0x35, + 0x36, 0x30, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x31, 0x38, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x46, 0x35, 0x35, 0x31, 0x30, + 0x44, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, + 0x44, 0x44, 0x38, 0x42, 0x43, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x36, 0x31, 0x42, 0x45, 0x33, 0x34, 0x43, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x45, 0x45, 0x34, 0x32, 0x34, + 0x37, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x30, 0x32, 0x31, 0x38, 0x39, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x35, 0x41, 0x32, 0x35, 0x45, 0x46, 0x30, 0x33, + 0x46, 0x0a, 0x31, 0x38, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x34, 0x39, 0x39, 0x45, 0x34, 0x44, 0x33, 0x35, 0x34, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x42, 0x45, 0x39, 0x44, 0x41, 0x46, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x46, 0x31, + 0x37, 0x44, 0x32, 0x36, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x43, 0x36, 0x37, 0x31, 0x37, 0x43, 0x35, 0x34, 0x37, 0x34, 0x30, + 0x0a, 0x31, 0x38, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x32, 0x33, 0x31, 0x43, 0x38, 0x41, 0x31, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x34, 0x34, 0x46, 0x31, 0x38, 0x38, 0x42, 0x34, + 0x37, 0x34, 0x30, 0x35, 0x35, 0x35, 0x37, 0x46, 0x41, 0x38, 0x39, 0x38, + 0x43, 0x42, 0x39, 0x33, 0x34, 0x34, 0x30, 0x35, 0x37, 0x44, 0x44, 0x31, + 0x43, 0x31, 0x38, 0x41, 0x30, 0x31, 0x32, 0x34, 0x45, 0x34, 0x30, 0x0a, + 0x31, 0x38, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, + 0x46, 0x46, 0x41, 0x42, 0x33, 0x36, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x45, 0x33, 0x42, 0x36, 0x35, 0x42, 0x43, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x45, 0x45, 0x34, 0x45, 0x41, + 0x45, 0x42, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, + 0x31, 0x35, 0x41, 0x39, 0x33, 0x45, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x31, + 0x38, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x45, 0x34, + 0x32, 0x43, 0x45, 0x45, 0x33, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x38, 0x34, 0x31, 0x34, 0x38, 0x31, 0x35, 0x33, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x44, 0x38, 0x33, 0x44, 0x41, + 0x45, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x35, + 0x45, 0x42, 0x31, 0x33, 0x30, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x31, 0x38, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x45, + 0x32, 0x30, 0x33, 0x30, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x38, 0x45, 0x39, 0x32, 0x42, 0x37, 0x32, 0x35, 0x32, 0x34, 0x30, + 0x44, 0x36, 0x30, 0x44, 0x42, 0x33, 0x36, 0x30, 0x31, 0x31, 0x32, 0x45, + 0x34, 0x45, 0x34, 0x30, 0x30, 0x46, 0x36, 0x42, 0x32, 0x38, 0x35, 0x45, + 0x35, 0x46, 0x30, 0x33, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x31, 0x38, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x37, + 0x45, 0x39, 0x39, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x43, 0x44, 0x42, 0x45, 0x42, 0x32, 0x39, 0x34, 0x31, 0x34, 0x30, 0x37, + 0x38, 0x35, 0x35, 0x44, 0x46, 0x44, 0x33, 0x37, 0x33, 0x35, 0x31, 0x33, + 0x36, 0x34, 0x30, 0x35, 0x39, 0x45, 0x35, 0x38, 0x37, 0x35, 0x36, 0x39, + 0x33, 0x44, 0x34, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x31, 0x39, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x37, 0x31, 0x30, 0x46, + 0x31, 0x39, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, + 0x34, 0x37, 0x44, 0x30, 0x45, 0x42, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x46, 0x43, 0x32, 0x30, 0x45, 0x32, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x33, 0x44, 0x35, + 0x43, 0x39, 0x34, 0x41, 0x34, 0x30, 0x39, 0x42, 0x37, 0x39, 0x34, 0x34, + 0x30, 0x41, 0x39, 0x32, 0x30, 0x46, 0x34, 0x30, 0x34, 0x30, 0x34, 0x38, + 0x33, 0x32, 0x30, 0x35, 0x30, 0x39, 0x38, 0x41, 0x37, 0x33, 0x34, 0x31, + 0x34, 0x30, 0x0a, 0x31, 0x39, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x45, 0x37, 0x44, 0x42, 0x43, 0x42, 0x33, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x37, 0x36, 0x42, 0x38, + 0x34, 0x45, 0x42, 0x33, 0x46, 0x39, 0x44, 0x35, 0x30, 0x35, 0x38, 0x33, + 0x31, 0x37, 0x38, 0x32, 0x32, 0x35, 0x31, 0x34, 0x30, 0x38, 0x30, 0x33, + 0x37, 0x39, 0x33, 0x42, 0x35, 0x42, 0x37, 0x43, 0x31, 0x33, 0x46, 0x34, + 0x30, 0x0a, 0x31, 0x39, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x30, 0x35, 0x37, 0x36, 0x33, 0x30, 0x36, 0x33, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x46, 0x38, 0x46, 0x36, 0x39, 0x43, + 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x43, 0x46, + 0x31, 0x46, 0x31, 0x38, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x32, 0x36, 0x31, 0x44, 0x38, 0x38, 0x36, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x41, 0x31, 0x30, 0x32, 0x41, 0x30, + 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x41, + 0x37, 0x41, 0x38, 0x39, 0x31, 0x31, 0x34, 0x30, 0x0a, 0x31, 0x39, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x46, 0x39, 0x44, + 0x41, 0x45, 0x31, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x38, 0x35, 0x34, 0x30, 0x34, 0x46, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x38, 0x41, 0x37, 0x32, 0x42, 0x31, 0x35, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x34, 0x45, 0x39, + 0x38, 0x38, 0x32, 0x32, 0x31, 0x34, 0x30, 0x33, 0x43, 0x33, 0x35, 0x39, + 0x36, 0x45, 0x43, 0x30, 0x37, 0x30, 0x42, 0x34, 0x44, 0x34, 0x30, 0x46, + 0x43, 0x42, 0x41, 0x37, 0x41, 0x45, 0x42, 0x41, 0x32, 0x30, 0x32, 0x33, + 0x35, 0x34, 0x30, 0x0a, 0x31, 0x39, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x37, 0x45, 0x43, 0x35, 0x41, 0x42, 0x34, 0x45, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x37, 0x36, 0x37, + 0x44, 0x43, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x36, + 0x46, 0x41, 0x38, 0x33, 0x37, 0x38, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x38, 0x42, 0x44, 0x41, 0x33, 0x33, 0x39, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x36, 0x45, 0x43, 0x36, + 0x43, 0x43, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x31, 0x45, 0x39, 0x41, 0x34, 0x33, 0x30, 0x46, 0x34, 0x30, 0x43, 0x45, + 0x36, 0x36, 0x33, 0x32, 0x43, 0x39, 0x39, 0x46, 0x43, 0x32, 0x35, 0x32, + 0x34, 0x30, 0x33, 0x36, 0x30, 0x46, 0x42, 0x46, 0x41, 0x31, 0x33, 0x31, + 0x37, 0x35, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x31, 0x39, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x34, 0x36, 0x30, 0x41, 0x37, + 0x31, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, + 0x32, 0x36, 0x30, 0x30, 0x38, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x30, 0x46, 0x31, 0x37, 0x37, 0x30, 0x34, 0x30, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x36, 0x41, 0x38, 0x30, 0x31, + 0x42, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x31, + 0x41, 0x30, 0x32, 0x33, 0x38, 0x32, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x34, 0x45, 0x41, 0x33, 0x32, 0x43, 0x37, 0x34, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x42, 0x34, 0x30, 0x42, 0x33, + 0x42, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x32, + 0x36, 0x35, 0x30, 0x34, 0x43, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x45, 0x31, 0x31, 0x42, 0x37, 0x36, 0x34, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x32, 0x39, 0x38, 0x30, 0x32, + 0x41, 0x34, 0x35, 0x34, 0x30, 0x0a, 0x31, 0x39, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x33, 0x36, 0x32, 0x35, 0x46, + 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x35, 0x45, + 0x39, 0x34, 0x37, 0x30, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x44, 0x30, 0x39, 0x46, 0x42, 0x43, 0x39, 0x43, 0x33, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x38, 0x35, 0x38, 0x39, 0x36, 0x41, + 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x36, 0x33, + 0x42, 0x39, 0x39, 0x45, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x32, 0x45, 0x33, 0x32, 0x46, 0x42, 0x31, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x42, 0x36, 0x41, 0x32, 0x31, + 0x31, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x32, 0x30, + 0x32, 0x33, 0x31, 0x43, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x46, 0x37, 0x46, 0x43, 0x45, 0x32, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x46, 0x45, 0x42, 0x31, + 0x45, 0x45, 0x33, 0x46, 0x0a, 0x31, 0x39, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x33, 0x34, 0x32, 0x39, 0x44, 0x36, 0x32, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, 0x46, 0x39, 0x42, + 0x33, 0x43, 0x38, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x34, 0x44, 0x46, 0x31, 0x45, 0x31, 0x37, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x38, 0x33, 0x30, 0x45, 0x36, 0x31, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x45, 0x46, 0x44, + 0x45, 0x33, 0x35, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x35, 0x41, 0x31, 0x43, 0x44, 0x34, 0x33, 0x46, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x43, 0x36, 0x34, 0x32, 0x44, 0x39, 0x39, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x34, 0x45, 0x30, 0x42, + 0x39, 0x41, 0x36, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x37, 0x37, 0x41, 0x36, 0x32, 0x46, 0x34, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x30, 0x44, 0x35, 0x31, 0x42, 0x38, 0x35, 0x35, + 0x36, 0x34, 0x30, 0x0a, 0x31, 0x39, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x38, 0x46, 0x36, 0x45, 0x44, 0x44, 0x46, 0x34, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, 0x33, 0x46, 0x39, 0x43, + 0x41, 0x30, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x44, 0x37, 0x43, 0x30, 0x35, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x38, 0x33, 0x39, 0x43, 0x32, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x41, 0x41, 0x45, 0x35, + 0x45, 0x42, 0x30, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, + 0x32, 0x39, 0x45, 0x36, 0x41, 0x38, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x31, + 0x39, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x38, + 0x34, 0x33, 0x45, 0x30, 0x39, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x30, 0x34, 0x38, 0x37, 0x44, 0x42, 0x46, 0x32, 0x34, 0x34, + 0x30, 0x35, 0x30, 0x33, 0x44, 0x38, 0x44, 0x36, 0x30, 0x32, 0x38, 0x32, + 0x34, 0x34, 0x39, 0x34, 0x30, 0x35, 0x36, 0x41, 0x42, 0x45, 0x43, 0x44, + 0x46, 0x34, 0x45, 0x32, 0x42, 0x34, 0x30, 0x34, 0x30, 0x0a, 0x32, 0x30, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x41, 0x39, + 0x30, 0x37, 0x42, 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x38, 0x32, 0x32, 0x39, 0x34, 0x43, 0x33, 0x34, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x35, 0x45, 0x41, 0x35, 0x36, 0x32, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x30, 0x34, + 0x32, 0x34, 0x43, 0x42, 0x35, 0x38, 0x34, 0x30, 0x42, 0x38, 0x34, 0x41, + 0x37, 0x33, 0x37, 0x44, 0x36, 0x41, 0x42, 0x33, 0x34, 0x37, 0x34, 0x30, + 0x45, 0x37, 0x36, 0x37, 0x44, 0x43, 0x42, 0x42, 0x42, 0x30, 0x33, 0x33, + 0x35, 0x35, 0x34, 0x30, 0x0a, 0x32, 0x30, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x32, 0x46, 0x36, 0x31, 0x46, 0x44, 0x32, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x45, 0x30, 0x30, 0x43, + 0x38, 0x38, 0x35, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x41, 0x37, 0x31, 0x32, 0x41, 0x34, 0x35, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x43, 0x35, 0x35, 0x35, 0x32, 0x34, 0x44, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x31, 0x45, 0x46, + 0x34, 0x31, 0x38, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x32, 0x43, 0x43, 0x32, 0x45, 0x46, 0x34, 0x35, 0x31, 0x34, 0x30, 0x0a, + 0x32, 0x30, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x41, 0x31, 0x35, 0x42, 0x34, 0x30, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x45, 0x38, 0x33, 0x36, 0x36, 0x32, 0x35, 0x38, + 0x34, 0x30, 0x45, 0x38, 0x36, 0x37, 0x42, 0x36, 0x42, 0x30, 0x33, 0x41, + 0x32, 0x42, 0x34, 0x32, 0x34, 0x30, 0x35, 0x31, 0x42, 0x44, 0x46, 0x41, + 0x39, 0x46, 0x45, 0x36, 0x31, 0x39, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x32, + 0x30, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x37, + 0x30, 0x35, 0x44, 0x35, 0x41, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x43, 0x32, 0x43, 0x46, 0x32, 0x33, 0x37, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, 0x41, 0x30, 0x36, 0x36, + 0x41, 0x33, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, + 0x42, 0x41, 0x30, 0x46, 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x34, 0x38, 0x35, 0x35, 0x30, 0x41, 0x39, 0x35, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x41, 0x33, 0x30, 0x39, + 0x34, 0x30, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x36, + 0x43, 0x36, 0x38, 0x37, 0x42, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x43, 0x45, 0x43, 0x46, 0x35, 0x44, 0x43, 0x34, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x44, 0x42, 0x46, 0x33, 0x33, + 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, 0x46, + 0x30, 0x38, 0x36, 0x44, 0x45, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x32, 0x30, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x39, + 0x34, 0x33, 0x30, 0x46, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x34, 0x39, 0x33, 0x33, 0x34, 0x32, 0x32, 0x34, 0x30, + 0x38, 0x32, 0x42, 0x44, 0x38, 0x36, 0x37, 0x34, 0x35, 0x37, 0x39, 0x44, + 0x34, 0x44, 0x34, 0x30, 0x36, 0x41, 0x44, 0x32, 0x46, 0x34, 0x34, 0x35, + 0x39, 0x37, 0x38, 0x37, 0x32, 0x46, 0x34, 0x30, 0x0a, 0x32, 0x30, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x42, 0x36, 0x33, + 0x36, 0x35, 0x31, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x38, 0x43, 0x42, 0x46, 0x36, 0x42, 0x39, 0x35, 0x35, 0x34, 0x30, 0x37, + 0x34, 0x39, 0x41, 0x41, 0x44, 0x42, 0x45, 0x31, 0x35, 0x39, 0x41, 0x32, + 0x46, 0x34, 0x30, 0x38, 0x33, 0x39, 0x44, 0x37, 0x46, 0x41, 0x36, 0x43, + 0x31, 0x32, 0x46, 0x33, 0x43, 0x34, 0x30, 0x0a, 0x32, 0x30, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x42, 0x46, 0x34, 0x38, + 0x44, 0x37, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x34, 0x44, 0x30, 0x36, 0x30, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x41, 0x38, 0x42, 0x33, 0x38, 0x42, 0x42, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, 0x38, 0x31, 0x32, 0x43, + 0x45, 0x41, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, + 0x35, 0x38, 0x36, 0x33, 0x41, 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x44, 0x45, 0x36, 0x34, 0x30, 0x30, 0x33, 0x34, + 0x34, 0x30, 0x44, 0x38, 0x33, 0x33, 0x35, 0x34, 0x32, 0x45, 0x30, 0x46, + 0x43, 0x30, 0x35, 0x37, 0x34, 0x30, 0x44, 0x31, 0x42, 0x44, 0x39, 0x44, + 0x34, 0x39, 0x45, 0x33, 0x43, 0x36, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x32, + 0x30, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x45, 0x39, + 0x34, 0x31, 0x31, 0x39, 0x44, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x34, 0x42, 0x35, 0x32, 0x33, 0x46, 0x31, 0x45, 0x34, + 0x30, 0x39, 0x45, 0x30, 0x30, 0x42, 0x33, 0x42, 0x30, 0x46, 0x41, 0x36, + 0x39, 0x34, 0x43, 0x34, 0x30, 0x36, 0x34, 0x44, 0x44, 0x31, 0x38, 0x38, + 0x41, 0x42, 0x31, 0x35, 0x36, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x32, 0x30, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x39, 0x30, + 0x46, 0x42, 0x45, 0x41, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x43, 0x30, 0x35, 0x30, 0x30, 0x46, 0x45, 0x34, 0x44, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x33, 0x46, 0x42, 0x45, 0x35, 0x42, + 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x34, + 0x34, 0x35, 0x36, 0x44, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x32, 0x30, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x36, 0x46, 0x39, + 0x30, 0x31, 0x31, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x30, 0x31, 0x30, 0x32, 0x44, 0x39, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x35, 0x46, 0x31, 0x44, 0x34, 0x42, 0x33, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x32, 0x45, + 0x39, 0x45, 0x35, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x38, 0x43, 0x31, 0x46, 0x33, 0x45, 0x41, 0x34, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x46, 0x43, 0x31, 0x32, 0x35, 0x34, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x36, 0x36, 0x32, 0x33, + 0x34, 0x30, 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x30, 0x30, 0x38, 0x33, 0x37, 0x42, 0x30, 0x32, 0x36, 0x34, 0x30, 0x0a, + 0x32, 0x31, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, + 0x41, 0x44, 0x31, 0x32, 0x36, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x34, 0x34, 0x33, 0x31, 0x41, 0x39, 0x31, 0x41, + 0x34, 0x30, 0x39, 0x44, 0x45, 0x31, 0x45, 0x37, 0x31, 0x33, 0x32, 0x45, + 0x39, 0x37, 0x35, 0x35, 0x34, 0x30, 0x31, 0x45, 0x33, 0x32, 0x42, 0x37, + 0x46, 0x30, 0x41, 0x41, 0x42, 0x41, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x32, + 0x31, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, + 0x39, 0x45, 0x36, 0x37, 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x39, 0x35, 0x39, 0x45, 0x38, 0x32, 0x34, 0x45, 0x34, + 0x30, 0x45, 0x33, 0x41, 0x32, 0x39, 0x41, 0x41, 0x35, 0x33, 0x39, 0x43, + 0x31, 0x34, 0x46, 0x34, 0x30, 0x34, 0x43, 0x39, 0x43, 0x38, 0x34, 0x32, + 0x35, 0x37, 0x39, 0x43, 0x42, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x32, 0x31, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x45, 0x31, 0x36, + 0x39, 0x31, 0x43, 0x46, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x43, 0x42, 0x39, 0x35, 0x33, 0x39, 0x45, 0x34, 0x34, 0x34, 0x30, + 0x34, 0x31, 0x45, 0x31, 0x41, 0x45, 0x35, 0x39, 0x45, 0x38, 0x35, 0x35, + 0x34, 0x30, 0x34, 0x30, 0x39, 0x43, 0x34, 0x35, 0x33, 0x42, 0x39, 0x33, + 0x35, 0x37, 0x32, 0x31, 0x32, 0x44, 0x34, 0x30, 0x0a, 0x32, 0x31, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x37, 0x42, + 0x34, 0x43, 0x45, 0x46, 0x32, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x43, 0x39, 0x37, 0x33, 0x30, 0x43, 0x30, 0x34, 0x44, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x41, 0x30, 0x46, 0x44, 0x45, 0x32, 0x34, 0x35, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x43, 0x35, 0x33, + 0x41, 0x36, 0x42, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x38, 0x42, 0x38, 0x41, 0x39, 0x38, 0x43, 0x34, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x34, 0x36, 0x42, 0x43, 0x39, 0x30, 0x46, 0x35, + 0x34, 0x34, 0x30, 0x0a, 0x32, 0x31, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x46, 0x38, 0x45, 0x33, 0x37, 0x45, 0x34, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x35, 0x35, 0x44, 0x32, + 0x46, 0x42, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, + 0x39, 0x44, 0x36, 0x41, 0x44, 0x38, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x34, 0x46, 0x39, 0x45, 0x41, 0x35, 0x34, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x32, 0x34, 0x30, 0x31, 0x32, + 0x41, 0x32, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, + 0x43, 0x33, 0x34, 0x38, 0x31, 0x32, 0x32, 0x43, 0x34, 0x30, 0x0a, 0x32, + 0x31, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, + 0x46, 0x34, 0x36, 0x45, 0x33, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x45, 0x42, 0x45, 0x35, 0x41, 0x32, 0x34, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x32, 0x42, 0x39, 0x37, 0x35, + 0x42, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x35, 0x43, 0x31, 0x33, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x45, 0x30, 0x41, 0x41, 0x38, 0x33, 0x44, 0x35, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x32, 0x30, 0x38, 0x35, 0x36, + 0x36, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x31, + 0x30, 0x31, 0x34, 0x36, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x36, 0x41, 0x38, 0x42, 0x42, 0x35, 0x30, 0x30, 0x34, + 0x30, 0x0a, 0x32, 0x31, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x32, 0x34, 0x35, 0x36, 0x30, 0x43, 0x39, 0x35, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x31, 0x33, 0x31, 0x36, 0x30, 0x32, + 0x35, 0x30, 0x34, 0x30, 0x45, 0x41, 0x30, 0x35, 0x45, 0x34, 0x38, 0x31, + 0x37, 0x30, 0x41, 0x44, 0x35, 0x34, 0x34, 0x30, 0x42, 0x30, 0x42, 0x37, + 0x37, 0x37, 0x39, 0x43, 0x38, 0x32, 0x46, 0x32, 0x34, 0x41, 0x34, 0x30, + 0x0a, 0x32, 0x31, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x33, 0x36, 0x46, 0x32, 0x43, 0x39, 0x31, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x38, 0x41, 0x36, 0x31, 0x43, 0x37, 0x44, 0x33, + 0x36, 0x34, 0x30, 0x33, 0x35, 0x31, 0x39, 0x36, 0x42, 0x41, 0x45, 0x35, + 0x32, 0x31, 0x42, 0x33, 0x30, 0x34, 0x30, 0x42, 0x35, 0x37, 0x39, 0x45, + 0x33, 0x34, 0x36, 0x33, 0x39, 0x42, 0x30, 0x34, 0x33, 0x34, 0x30, 0x0a, + 0x32, 0x31, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, + 0x43, 0x46, 0x33, 0x34, 0x46, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x45, 0x43, 0x31, 0x42, 0x36, 0x39, 0x36, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x39, 0x41, 0x33, 0x39, + 0x45, 0x37, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x32, 0x39, 0x32, 0x41, 0x37, 0x37, 0x34, 0x42, 0x34, 0x30, 0x34, 0x45, + 0x31, 0x31, 0x36, 0x44, 0x36, 0x42, 0x38, 0x36, 0x39, 0x30, 0x33, 0x44, + 0x34, 0x30, 0x44, 0x43, 0x44, 0x42, 0x42, 0x46, 0x46, 0x46, 0x42, 0x44, + 0x36, 0x35, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x32, 0x31, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x30, 0x31, 0x43, 0x45, 0x41, + 0x44, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x41, + 0x31, 0x34, 0x38, 0x42, 0x33, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x45, 0x33, 0x45, 0x45, 0x41, 0x30, 0x34, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x46, 0x46, 0x34, 0x34, 0x46, + 0x38, 0x35, 0x38, 0x34, 0x30, 0x43, 0x35, 0x43, 0x37, 0x35, 0x45, 0x30, + 0x45, 0x46, 0x45, 0x43, 0x45, 0x34, 0x32, 0x34, 0x30, 0x43, 0x33, 0x43, + 0x44, 0x30, 0x34, 0x44, 0x31, 0x42, 0x41, 0x30, 0x41, 0x34, 0x42, 0x34, + 0x30, 0x0a, 0x32, 0x32, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x38, 0x34, 0x46, 0x31, 0x46, 0x41, 0x42, 0x33, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x36, 0x33, 0x30, 0x46, 0x44, 0x36, + 0x32, 0x31, 0x34, 0x30, 0x33, 0x43, 0x33, 0x35, 0x45, 0x45, 0x37, 0x34, + 0x32, 0x32, 0x44, 0x38, 0x34, 0x42, 0x34, 0x30, 0x37, 0x30, 0x38, 0x38, + 0x44, 0x31, 0x43, 0x43, 0x39, 0x39, 0x35, 0x42, 0x34, 0x39, 0x34, 0x30, + 0x0a, 0x32, 0x32, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x30, 0x37, 0x37, 0x33, 0x31, 0x43, 0x34, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x38, 0x37, 0x45, 0x37, 0x39, 0x33, 0x38, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x31, 0x37, 0x36, + 0x38, 0x32, 0x35, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x32, 0x32, 0x34, 0x46, 0x33, 0x44, 0x34, 0x35, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x34, 0x35, 0x33, 0x42, 0x39, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x35, 0x45, 0x43, + 0x43, 0x43, 0x31, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x32, 0x34, 0x41, 0x36, 0x33, 0x36, 0x34, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x35, 0x44, 0x38, 0x37, 0x35, 0x35, + 0x32, 0x34, 0x30, 0x0a, 0x32, 0x32, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x38, 0x43, 0x43, 0x34, 0x34, 0x43, 0x37, 0x34, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x34, 0x46, 0x41, 0x41, 0x41, + 0x37, 0x39, 0x34, 0x31, 0x34, 0x30, 0x46, 0x33, 0x37, 0x41, 0x43, 0x31, + 0x41, 0x42, 0x34, 0x37, 0x35, 0x43, 0x34, 0x42, 0x34, 0x30, 0x31, 0x33, + 0x30, 0x46, 0x46, 0x46, 0x36, 0x33, 0x42, 0x30, 0x42, 0x44, 0x34, 0x31, + 0x34, 0x30, 0x0a, 0x32, 0x32, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x41, 0x32, 0x38, 0x44, 0x38, 0x35, 0x33, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x33, 0x33, 0x33, 0x31, 0x45, + 0x42, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x36, + 0x33, 0x32, 0x34, 0x41, 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x34, 0x37, 0x35, 0x39, 0x44, 0x31, 0x46, 0x35, 0x38, 0x34, + 0x30, 0x0a, 0x32, 0x32, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x38, 0x41, 0x30, 0x37, 0x37, 0x43, 0x31, 0x33, 0x45, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x36, 0x39, 0x42, 0x34, 0x37, 0x37, + 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x45, 0x35, 0x39, + 0x33, 0x42, 0x39, 0x35, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x30, 0x33, 0x31, 0x34, 0x34, 0x31, 0x35, 0x33, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x32, 0x36, 0x42, 0x36, 0x44, 0x34, + 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x31, + 0x38, 0x36, 0x44, 0x38, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x31, 0x45, 0x41, 0x34, 0x41, 0x30, 0x35, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x45, 0x41, 0x35, 0x42, 0x42, 0x30, + 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x42, 0x37, + 0x44, 0x34, 0x46, 0x45, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x38, 0x31, 0x33, 0x31, 0x41, 0x31, 0x31, 0x33, 0x38, 0x34, 0x30, + 0x0a, 0x32, 0x32, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x36, 0x36, 0x34, 0x39, 0x42, 0x46, 0x35, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x34, 0x33, 0x35, 0x33, 0x35, 0x30, 0x37, 0x34, + 0x46, 0x34, 0x30, 0x31, 0x33, 0x31, 0x34, 0x43, 0x44, 0x35, 0x43, 0x44, + 0x37, 0x35, 0x39, 0x35, 0x32, 0x34, 0x30, 0x44, 0x41, 0x45, 0x37, 0x44, + 0x44, 0x42, 0x33, 0x39, 0x39, 0x39, 0x44, 0x35, 0x31, 0x34, 0x30, 0x0a, + 0x32, 0x32, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x38, 0x41, 0x32, 0x38, 0x43, 0x36, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x32, 0x37, 0x31, 0x34, 0x35, 0x45, 0x33, 0x39, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x31, 0x44, + 0x44, 0x37, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x36, + 0x43, 0x36, 0x34, 0x37, 0x32, 0x41, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x30, 0x32, 0x41, 0x44, 0x33, 0x42, 0x35, 0x31, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x30, 0x45, 0x35, 0x42, + 0x45, 0x36, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x32, 0x32, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x35, 0x35, 0x35, + 0x46, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x30, + 0x42, 0x45, 0x33, 0x39, 0x31, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x30, 0x31, 0x32, 0x43, 0x41, 0x37, 0x43, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x42, 0x42, 0x41, 0x39, 0x30, + 0x44, 0x34, 0x38, 0x34, 0x30, 0x35, 0x42, 0x41, 0x41, 0x33, 0x36, 0x36, + 0x42, 0x35, 0x39, 0x42, 0x45, 0x35, 0x32, 0x34, 0x30, 0x42, 0x39, 0x31, + 0x37, 0x34, 0x41, 0x31, 0x35, 0x46, 0x45, 0x41, 0x42, 0x34, 0x39, 0x34, + 0x30, 0x0a, 0x32, 0x32, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x30, 0x43, 0x32, 0x30, 0x35, 0x41, 0x37, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x38, 0x38, 0x38, 0x44, 0x33, 0x42, + 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x45, + 0x37, 0x43, 0x43, 0x38, 0x46, 0x38, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x34, 0x42, 0x41, 0x34, 0x30, 0x35, 0x35, 0x34, 0x43, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x41, 0x36, 0x31, 0x44, 0x35, 0x37, 0x32, + 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x38, 0x46, + 0x46, 0x38, 0x36, 0x36, 0x35, 0x36, 0x34, 0x30, 0x0a, 0x32, 0x32, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x32, 0x46, 0x38, 0x41, + 0x35, 0x46, 0x44, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x45, 0x34, 0x45, 0x43, 0x43, 0x42, 0x33, 0x35, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x43, 0x45, 0x44, 0x37, 0x38, 0x46, 0x39, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x41, 0x36, 0x32, 0x45, + 0x42, 0x35, 0x33, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x36, 0x33, 0x31, 0x46, 0x34, 0x33, 0x46, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x43, 0x36, 0x37, 0x36, 0x39, 0x36, 0x34, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x39, 0x45, 0x46, + 0x45, 0x44, 0x42, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x36, 0x33, 0x42, 0x37, 0x39, 0x39, 0x37, 0x35, 0x37, 0x34, 0x30, 0x0a, + 0x32, 0x33, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, + 0x36, 0x45, 0x34, 0x37, 0x36, 0x31, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x41, 0x30, 0x39, 0x42, 0x42, 0x35, 0x46, 0x30, + 0x33, 0x46, 0x35, 0x46, 0x43, 0x41, 0x32, 0x43, 0x44, 0x41, 0x46, 0x36, + 0x32, 0x38, 0x32, 0x32, 0x34, 0x30, 0x37, 0x34, 0x38, 0x31, 0x43, 0x31, + 0x34, 0x44, 0x43, 0x39, 0x34, 0x46, 0x34, 0x30, 0x34, 0x30, 0x0a, 0x32, + 0x33, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x35, + 0x37, 0x38, 0x32, 0x42, 0x36, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x36, 0x30, 0x39, 0x35, 0x38, 0x34, 0x46, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x30, 0x38, 0x43, 0x32, 0x44, + 0x45, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x34, + 0x38, 0x34, 0x45, 0x42, 0x36, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x43, 0x43, 0x35, 0x44, 0x46, 0x36, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x43, 0x38, 0x32, 0x37, 0x30, + 0x44, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x32, + 0x46, 0x39, 0x32, 0x37, 0x43, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x41, 0x35, 0x46, 0x38, 0x38, 0x33, 0x33, 0x38, 0x34, + 0x30, 0x0a, 0x32, 0x33, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x34, 0x34, 0x45, 0x38, 0x33, 0x34, 0x41, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x39, 0x39, 0x39, 0x32, 0x46, 0x36, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x33, 0x46, + 0x30, 0x46, 0x37, 0x37, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x44, 0x35, 0x33, 0x37, 0x36, 0x34, 0x33, 0x39, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x45, 0x39, 0x30, 0x38, 0x44, 0x33, + 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x34, 0x33, + 0x46, 0x35, 0x39, 0x35, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x32, 0x33, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x36, 0x41, + 0x45, 0x36, 0x34, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x32, 0x34, 0x39, 0x46, 0x41, 0x30, 0x31, 0x35, 0x35, 0x34, 0x30, 0x33, + 0x32, 0x32, 0x33, 0x33, 0x39, 0x30, 0x38, 0x41, 0x30, 0x34, 0x35, 0x34, + 0x43, 0x34, 0x30, 0x31, 0x37, 0x46, 0x42, 0x45, 0x42, 0x30, 0x41, 0x34, + 0x41, 0x45, 0x30, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x32, 0x33, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x33, 0x44, 0x38, 0x33, + 0x35, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, + 0x34, 0x30, 0x36, 0x42, 0x34, 0x39, 0x34, 0x34, 0x34, 0x30, 0x39, 0x45, + 0x42, 0x35, 0x31, 0x44, 0x37, 0x36, 0x37, 0x38, 0x37, 0x37, 0x34, 0x35, + 0x34, 0x30, 0x38, 0x41, 0x46, 0x36, 0x32, 0x42, 0x41, 0x35, 0x32, 0x30, + 0x45, 0x41, 0x34, 0x42, 0x34, 0x30, 0x0a, 0x32, 0x33, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x36, 0x44, 0x37, 0x42, 0x37, + 0x34, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, + 0x43, 0x38, 0x44, 0x30, 0x34, 0x32, 0x35, 0x34, 0x30, 0x46, 0x45, 0x42, + 0x31, 0x44, 0x46, 0x41, 0x36, 0x44, 0x42, 0x32, 0x45, 0x35, 0x30, 0x34, + 0x30, 0x35, 0x43, 0x39, 0x43, 0x39, 0x36, 0x35, 0x45, 0x31, 0x41, 0x43, + 0x42, 0x33, 0x41, 0x34, 0x30, 0x0a, 0x32, 0x33, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x32, 0x39, 0x30, 0x44, 0x33, + 0x32, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x34, 0x45, + 0x39, 0x32, 0x30, 0x43, 0x34, 0x32, 0x34, 0x30, 0x32, 0x35, 0x36, 0x38, + 0x39, 0x31, 0x35, 0x46, 0x36, 0x30, 0x39, 0x36, 0x33, 0x43, 0x34, 0x30, + 0x33, 0x34, 0x46, 0x34, 0x34, 0x34, 0x33, 0x41, 0x38, 0x42, 0x38, 0x30, + 0x34, 0x46, 0x34, 0x30, 0x0a, 0x32, 0x33, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x38, 0x30, 0x41, 0x32, 0x32, 0x42, 0x32, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x35, 0x35, 0x34, + 0x38, 0x31, 0x46, 0x34, 0x41, 0x34, 0x30, 0x37, 0x38, 0x35, 0x45, 0x38, + 0x35, 0x33, 0x42, 0x36, 0x30, 0x38, 0x43, 0x32, 0x45, 0x34, 0x30, 0x42, + 0x45, 0x43, 0x39, 0x43, 0x33, 0x44, 0x33, 0x35, 0x36, 0x32, 0x45, 0x34, + 0x45, 0x34, 0x30, 0x0a, 0x32, 0x33, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x34, 0x44, 0x35, 0x36, 0x46, 0x44, 0x37, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x39, 0x44, 0x36, + 0x34, 0x33, 0x35, 0x32, 0x34, 0x30, 0x45, 0x42, 0x41, 0x37, 0x33, 0x31, + 0x37, 0x39, 0x46, 0x31, 0x32, 0x36, 0x35, 0x31, 0x34, 0x30, 0x33, 0x42, + 0x31, 0x34, 0x45, 0x33, 0x33, 0x39, 0x41, 0x42, 0x45, 0x34, 0x35, 0x33, + 0x34, 0x30, 0x0a, 0x32, 0x33, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x45, 0x41, 0x46, 0x38, 0x36, 0x44, 0x45, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x45, 0x31, 0x35, 0x34, 0x43, 0x31, + 0x32, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, + 0x38, 0x39, 0x30, 0x42, 0x30, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x34, 0x46, 0x46, 0x46, 0x41, 0x45, 0x33, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x38, 0x30, 0x45, 0x30, 0x34, + 0x33, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x32, + 0x42, 0x37, 0x30, 0x39, 0x42, 0x34, 0x39, 0x34, 0x30, 0x42, 0x45, 0x33, + 0x42, 0x31, 0x32, 0x41, 0x32, 0x41, 0x45, 0x34, 0x34, 0x34, 0x36, 0x34, + 0x30, 0x43, 0x35, 0x46, 0x39, 0x46, 0x46, 0x33, 0x31, 0x36, 0x41, 0x38, + 0x34, 0x34, 0x34, 0x34, 0x30, 0x0a, 0x32, 0x34, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x32, 0x43, 0x34, 0x32, 0x35, 0x45, 0x42, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x41, 0x32, 0x32, + 0x45, 0x30, 0x42, 0x45, 0x35, 0x30, 0x34, 0x30, 0x36, 0x35, 0x37, 0x31, + 0x44, 0x38, 0x42, 0x46, 0x41, 0x42, 0x36, 0x43, 0x35, 0x35, 0x34, 0x30, + 0x46, 0x30, 0x38, 0x30, 0x43, 0x32, 0x33, 0x35, 0x43, 0x38, 0x44, 0x33, + 0x35, 0x30, 0x34, 0x30, 0x0a, 0x32, 0x34, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x38, 0x38, 0x43, 0x32, 0x33, 0x34, 0x42, 0x33, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x31, 0x43, + 0x31, 0x43, 0x42, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x45, 0x45, 0x39, 0x39, 0x34, 0x33, 0x31, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x44, 0x32, 0x45, 0x42, 0x36, 0x43, 0x34, + 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x43, 0x37, + 0x39, 0x41, 0x45, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x30, 0x44, 0x39, 0x42, 0x36, 0x35, 0x38, 0x32, 0x45, 0x34, 0x30, 0x0a, + 0x32, 0x34, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x43, 0x35, 0x39, 0x32, 0x31, 0x36, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x42, 0x38, 0x38, 0x32, 0x35, 0x46, 0x38, 0x34, 0x34, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x36, 0x36, 0x33, 0x31, + 0x34, 0x30, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, + 0x34, 0x36, 0x46, 0x37, 0x46, 0x35, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x32, 0x37, 0x44, 0x42, 0x38, 0x39, 0x30, 0x35, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, 0x34, + 0x45, 0x46, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x32, 0x34, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x43, 0x33, 0x45, 0x44, 0x45, + 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, + 0x46, 0x44, 0x34, 0x45, 0x45, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x30, 0x32, 0x35, 0x39, 0x43, 0x35, 0x32, 0x32, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x45, 0x35, 0x43, 0x44, 0x41, + 0x36, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x32, 0x34, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x38, 0x42, 0x36, 0x34, 0x32, + 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x46, 0x41, + 0x42, 0x37, 0x44, 0x38, 0x32, 0x42, 0x34, 0x30, 0x31, 0x33, 0x43, 0x36, + 0x31, 0x42, 0x34, 0x45, 0x38, 0x32, 0x33, 0x41, 0x34, 0x45, 0x34, 0x30, + 0x42, 0x39, 0x42, 0x34, 0x31, 0x45, 0x33, 0x44, 0x37, 0x30, 0x46, 0x32, + 0x32, 0x38, 0x34, 0x30, 0x0a, 0x32, 0x34, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x34, 0x34, 0x35, 0x34, 0x42, 0x45, 0x43, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x38, + 0x34, 0x38, 0x38, 0x44, 0x30, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x36, 0x38, 0x36, 0x46, 0x44, 0x44, 0x34, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x44, 0x46, 0x36, 0x35, 0x43, 0x34, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x41, 0x42, + 0x39, 0x35, 0x30, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x34, 0x35, 0x32, 0x46, 0x32, 0x39, 0x46, 0x34, 0x34, 0x34, 0x30, 0x45, + 0x36, 0x35, 0x35, 0x45, 0x46, 0x38, 0x43, 0x32, 0x38, 0x36, 0x38, 0x34, + 0x33, 0x34, 0x30, 0x42, 0x46, 0x38, 0x39, 0x34, 0x45, 0x43, 0x43, 0x45, + 0x43, 0x36, 0x46, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x32, 0x34, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x46, 0x30, 0x35, + 0x44, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, + 0x33, 0x33, 0x44, 0x37, 0x43, 0x39, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x32, 0x37, 0x32, 0x39, 0x37, 0x36, 0x31, 0x32, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x38, 0x37, 0x38, 0x41, + 0x45, 0x37, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x42, 0x39, 0x32, 0x37, 0x39, 0x32, 0x33, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x42, 0x34, 0x42, 0x36, 0x36, 0x30, 0x35, 0x30, + 0x34, 0x30, 0x0a, 0x32, 0x34, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x45, 0x35, 0x43, 0x44, 0x44, 0x32, 0x34, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x32, 0x34, 0x30, 0x36, 0x45, + 0x37, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x35, + 0x43, 0x33, 0x32, 0x30, 0x39, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x43, 0x43, 0x31, 0x37, 0x33, 0x34, 0x39, 0x34, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x41, 0x37, 0x44, 0x42, 0x36, + 0x33, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x43, + 0x45, 0x39, 0x31, 0x43, 0x33, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x43, 0x41, 0x38, 0x34, 0x36, 0x41, 0x34, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x42, 0x33, 0x44, 0x36, 0x30, + 0x44, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x37, + 0x41, 0x35, 0x46, 0x31, 0x46, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x30, 0x31, 0x43, 0x35, 0x35, 0x46, 0x31, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x33, 0x45, 0x34, 0x35, + 0x36, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x46, + 0x45, 0x39, 0x32, 0x44, 0x45, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x32, 0x34, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x42, 0x31, + 0x32, 0x44, 0x31, 0x38, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x30, 0x31, 0x39, 0x44, 0x31, 0x31, 0x36, 0x33, 0x32, 0x34, 0x30, + 0x45, 0x43, 0x46, 0x45, 0x41, 0x44, 0x36, 0x30, 0x39, 0x30, 0x37, 0x38, + 0x34, 0x33, 0x34, 0x30, 0x41, 0x36, 0x34, 0x33, 0x35, 0x46, 0x42, 0x39, + 0x45, 0x31, 0x31, 0x34, 0x33, 0x42, 0x34, 0x30, 0x0a, 0x32, 0x34, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x35, 0x36, 0x43, + 0x42, 0x30, 0x33, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x34, 0x35, 0x34, 0x35, 0x39, 0x43, 0x41, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x43, 0x42, 0x43, 0x45, 0x30, 0x36, 0x45, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x45, 0x30, 0x43, + 0x39, 0x42, 0x34, 0x31, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x43, 0x44, 0x42, 0x38, 0x37, 0x42, 0x34, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x33, 0x43, 0x46, 0x39, 0x42, 0x32, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x46, 0x44, 0x30, + 0x43, 0x32, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x32, 0x33, 0x41, 0x43, 0x41, 0x36, 0x46, 0x35, 0x33, 0x34, 0x30, 0x0a, + 0x32, 0x35, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x45, 0x34, 0x34, 0x38, 0x34, 0x35, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x41, 0x32, 0x41, 0x43, 0x42, 0x35, 0x32, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x43, 0x35, 0x45, 0x45, + 0x31, 0x44, 0x32, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, + 0x33, 0x34, 0x34, 0x35, 0x43, 0x42, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x45, 0x31, 0x37, 0x39, 0x41, 0x43, 0x44, 0x35, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x42, 0x42, 0x38, 0x36, + 0x31, 0x32, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, + 0x30, 0x31, 0x46, 0x46, 0x32, 0x31, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x39, 0x36, 0x34, 0x45, 0x33, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x37, 0x37, 0x31, 0x34, + 0x41, 0x30, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x41, 0x31, 0x43, 0x33, 0x31, 0x42, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x32, + 0x35, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x32, + 0x32, 0x35, 0x31, 0x37, 0x37, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x41, 0x38, 0x31, 0x43, 0x31, 0x35, 0x35, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x37, 0x44, 0x43, 0x33, 0x39, + 0x44, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x36, + 0x34, 0x41, 0x34, 0x42, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x45, 0x43, 0x41, 0x43, 0x32, 0x42, 0x32, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x35, 0x44, 0x38, 0x46, 0x46, + 0x33, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x32, 0x35, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, 0x31, 0x43, 0x35, 0x44, 0x32, + 0x31, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x43, 0x36, 0x42, + 0x32, 0x33, 0x39, 0x37, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x30, 0x37, 0x42, 0x44, 0x33, 0x42, 0x30, 0x33, 0x46, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x39, 0x31, 0x35, 0x30, 0x35, 0x31, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x32, 0x44, + 0x31, 0x32, 0x33, 0x32, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x43, 0x33, 0x33, 0x38, 0x45, 0x43, 0x45, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x31, 0x33, 0x32, 0x34, 0x35, 0x45, + 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x36, 0x39, + 0x41, 0x42, 0x30, 0x38, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x34, 0x44, 0x35, 0x31, 0x38, 0x34, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x42, 0x44, 0x30, 0x42, 0x32, 0x43, + 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x34, + 0x35, 0x43, 0x39, 0x34, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x41, 0x34, 0x41, 0x36, 0x45, 0x31, 0x32, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x34, 0x44, 0x36, 0x31, 0x45, 0x46, + 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x31, 0x38, + 0x41, 0x35, 0x44, 0x39, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x32, 0x35, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x32, 0x36, 0x31, + 0x46, 0x37, 0x33, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x45, 0x34, 0x43, 0x45, 0x41, 0x41, 0x34, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x32, 0x32, 0x34, 0x30, 0x34, 0x32, + 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x43, 0x46, 0x44, 0x36, + 0x46, 0x44, 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x33, 0x34, 0x41, 0x37, 0x44, 0x37, 0x33, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x38, 0x35, 0x34, 0x41, 0x38, 0x34, + 0x32, 0x34, 0x30, 0x0a, 0x32, 0x35, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x32, 0x39, 0x44, 0x43, 0x42, 0x43, 0x33, 0x35, 0x34, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x43, 0x34, 0x41, 0x41, + 0x34, 0x45, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, + 0x35, 0x41, 0x33, 0x42, 0x46, 0x32, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x38, 0x33, 0x46, 0x31, 0x41, 0x33, 0x33, 0x34, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x38, 0x34, 0x44, 0x43, + 0x44, 0x38, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x45, 0x46, 0x46, 0x42, 0x32, 0x44, 0x30, 0x41, 0x34, 0x30, 0x0a, 0x32, + 0x35, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x44, + 0x30, 0x46, 0x45, 0x45, 0x46, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x30, 0x31, 0x45, 0x30, 0x32, 0x36, 0x43, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x30, 0x45, 0x32, 0x46, 0x42, + 0x43, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x41, 0x33, + 0x42, 0x32, 0x32, 0x38, 0x37, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x38, 0x46, 0x44, 0x33, 0x36, 0x37, 0x30, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x32, 0x37, 0x35, 0x34, + 0x44, 0x31, 0x36, 0x34, 0x30, 0x42, 0x41, 0x41, 0x37, 0x38, 0x33, 0x42, + 0x37, 0x38, 0x38, 0x36, 0x36, 0x35, 0x30, 0x34, 0x30, 0x43, 0x36, 0x39, + 0x41, 0x34, 0x33, 0x39, 0x32, 0x30, 0x33, 0x39, 0x30, 0x32, 0x45, 0x34, + 0x30, 0x0a, 0x32, 0x35, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x30, 0x41, 0x38, 0x30, 0x34, 0x32, 0x35, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, 0x39, 0x45, 0x37, 0x34, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x46, 0x45, + 0x31, 0x44, 0x34, 0x46, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x38, 0x38, 0x32, 0x42, 0x32, 0x44, 0x44, 0x33, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x31, 0x41, 0x37, 0x46, 0x35, + 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, 0x41, + 0x33, 0x42, 0x46, 0x35, 0x31, 0x33, 0x34, 0x30, 0x0a, 0x32, 0x35, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x38, 0x43, 0x46, + 0x44, 0x43, 0x45, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x36, 0x36, 0x32, 0x33, 0x46, 0x33, 0x33, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x38, 0x32, 0x46, 0x38, 0x38, 0x43, 0x34, 0x33, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x44, 0x45, 0x41, + 0x35, 0x45, 0x43, 0x34, 0x35, 0x34, 0x30, 0x36, 0x33, 0x45, 0x42, 0x31, + 0x45, 0x42, 0x34, 0x43, 0x32, 0x31, 0x32, 0x34, 0x39, 0x34, 0x30, 0x36, + 0x45, 0x38, 0x36, 0x44, 0x30, 0x42, 0x41, 0x42, 0x42, 0x45, 0x39, 0x34, + 0x43, 0x34, 0x30, 0x0a, 0x32, 0x35, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x44, 0x41, 0x38, 0x33, 0x39, 0x37, 0x33, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x37, 0x32, 0x41, 0x43, + 0x38, 0x45, 0x33, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, + 0x30, 0x35, 0x31, 0x46, 0x34, 0x37, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x33, 0x37, 0x45, 0x31, 0x32, 0x41, 0x33, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, 0x44, 0x46, 0x41, 0x43, + 0x30, 0x37, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x33, 0x42, 0x34, 0x42, 0x32, 0x35, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x43, 0x35, 0x33, 0x33, 0x31, 0x30, 0x45, 0x34, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x44, 0x45, 0x35, 0x44, + 0x41, 0x31, 0x33, 0x30, 0x34, 0x30, 0x45, 0x39, 0x37, 0x39, 0x31, 0x41, + 0x39, 0x41, 0x36, 0x34, 0x35, 0x32, 0x34, 0x31, 0x34, 0x30, 0x43, 0x34, + 0x35, 0x36, 0x46, 0x35, 0x34, 0x42, 0x42, 0x33, 0x36, 0x33, 0x34, 0x32, + 0x34, 0x30, 0x0a, 0x32, 0x35, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x30, 0x33, 0x41, 0x39, 0x31, 0x42, 0x43, 0x33, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x35, 0x31, 0x34, 0x37, 0x35, + 0x36, 0x34, 0x45, 0x34, 0x30, 0x42, 0x35, 0x34, 0x34, 0x46, 0x45, 0x35, + 0x32, 0x41, 0x46, 0x37, 0x44, 0x33, 0x43, 0x34, 0x30, 0x44, 0x38, 0x44, + 0x37, 0x46, 0x44, 0x31, 0x39, 0x38, 0x30, 0x42, 0x44, 0x34, 0x44, 0x34, + 0x30, 0x0a, 0x32, 0x36, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x38, 0x36, 0x44, 0x46, 0x41, 0x46, 0x42, 0x34, 0x42, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x33, 0x39, 0x44, 0x45, 0x37, 0x30, + 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, + 0x35, 0x38, 0x44, 0x36, 0x44, 0x42, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x34, 0x32, 0x44, 0x44, 0x45, 0x32, 0x33, 0x35, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x33, 0x39, 0x31, 0x41, 0x39, 0x43, + 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x42, 0x36, + 0x43, 0x42, 0x37, 0x45, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x38, 0x37, 0x42, 0x39, 0x36, 0x41, 0x45, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x34, 0x36, 0x38, 0x35, 0x46, 0x46, + 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x31, 0x45, + 0x37, 0x35, 0x34, 0x33, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x43, 0x34, 0x41, 0x35, 0x45, 0x36, 0x42, 0x34, 0x33, 0x34, 0x30, + 0x0a, 0x32, 0x36, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x43, 0x31, 0x42, 0x37, 0x45, 0x39, 0x45, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x38, 0x33, 0x36, 0x35, 0x36, 0x38, 0x38, 0x34, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x41, 0x35, 0x45, + 0x36, 0x34, 0x42, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x41, 0x32, 0x43, 0x32, 0x38, 0x43, 0x34, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x44, 0x37, 0x39, 0x32, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x42, 0x39, 0x36, + 0x37, 0x33, 0x41, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x38, 0x34, 0x42, 0x38, 0x31, 0x43, 0x44, 0x33, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x43, 0x46, 0x38, 0x38, 0x46, 0x33, 0x38, 0x35, + 0x35, 0x34, 0x30, 0x0a, 0x32, 0x36, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x38, 0x30, 0x38, 0x42, 0x30, 0x37, 0x35, 0x33, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x36, 0x32, 0x30, + 0x39, 0x43, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, + 0x37, 0x34, 0x34, 0x36, 0x38, 0x33, 0x33, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x30, 0x46, 0x33, 0x41, 0x39, 0x42, 0x33, 0x32, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x45, 0x42, 0x34, 0x38, + 0x39, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x34, + 0x37, 0x46, 0x44, 0x42, 0x35, 0x34, 0x34, 0x41, 0x34, 0x30, 0x0a, 0x32, + 0x36, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, + 0x33, 0x43, 0x31, 0x43, 0x44, 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x34, 0x31, 0x43, 0x37, 0x32, 0x37, 0x44, 0x34, 0x46, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x34, 0x43, 0x36, 0x46, 0x43, + 0x33, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x32, + 0x43, 0x45, 0x45, 0x31, 0x42, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x38, 0x31, 0x33, 0x44, 0x39, 0x46, 0x32, 0x33, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, 0x43, 0x32, 0x32, 0x36, 0x31, + 0x41, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x38, + 0x34, 0x43, 0x34, 0x33, 0x37, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x41, 0x37, 0x32, 0x39, 0x34, 0x45, 0x30, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x46, 0x37, 0x38, 0x31, 0x36, + 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, + 0x33, 0x41, 0x36, 0x37, 0x32, 0x31, 0x37, 0x34, 0x30, 0x0a, 0x32, 0x36, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x34, 0x39, + 0x36, 0x33, 0x41, 0x43, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x34, 0x44, 0x45, 0x43, 0x39, 0x33, 0x31, 0x34, 0x38, 0x34, 0x30, + 0x43, 0x38, 0x32, 0x32, 0x39, 0x39, 0x39, 0x37, 0x39, 0x43, 0x46, 0x37, + 0x34, 0x38, 0x34, 0x30, 0x42, 0x30, 0x46, 0x31, 0x42, 0x43, 0x44, 0x33, + 0x30, 0x39, 0x33, 0x38, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x32, 0x36, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x36, 0x43, 0x33, + 0x38, 0x38, 0x41, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x42, 0x34, 0x38, 0x32, 0x37, 0x31, 0x34, 0x39, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x36, 0x32, 0x37, 0x35, 0x46, 0x35, 0x39, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x33, 0x38, 0x38, + 0x34, 0x36, 0x46, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x34, 0x31, 0x44, 0x33, 0x42, 0x42, 0x32, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x36, 0x41, 0x42, 0x36, 0x44, 0x38, 0x32, + 0x31, 0x34, 0x30, 0x0a, 0x32, 0x36, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x35, 0x39, 0x36, 0x31, 0x36, 0x38, 0x34, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, 0x39, 0x30, 0x33, 0x44, + 0x35, 0x35, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, + 0x43, 0x44, 0x37, 0x34, 0x38, 0x42, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x37, 0x44, 0x31, 0x34, 0x35, 0x33, 0x33, 0x38, + 0x34, 0x30, 0x0a, 0x32, 0x36, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x36, 0x32, 0x44, 0x39, 0x46, 0x30, 0x32, 0x35, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x36, 0x37, 0x38, 0x30, 0x31, + 0x46, 0x32, 0x35, 0x34, 0x30, 0x45, 0x44, 0x37, 0x30, 0x36, 0x44, 0x37, + 0x44, 0x37, 0x34, 0x39, 0x42, 0x34, 0x30, 0x34, 0x30, 0x42, 0x32, 0x46, + 0x38, 0x31, 0x37, 0x34, 0x33, 0x35, 0x33, 0x36, 0x30, 0x33, 0x34, 0x34, + 0x30, 0x0a, 0x32, 0x36, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x43, 0x42, 0x30, 0x37, 0x37, 0x41, 0x32, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x30, 0x39, 0x39, 0x41, 0x42, 0x35, + 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x33, 0x46, + 0x42, 0x39, 0x38, 0x43, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x34, 0x34, 0x32, 0x37, 0x30, 0x35, 0x33, 0x46, 0x34, 0x30, + 0x36, 0x36, 0x31, 0x44, 0x33, 0x32, 0x35, 0x38, 0x32, 0x30, 0x36, 0x30, + 0x34, 0x44, 0x34, 0x30, 0x32, 0x46, 0x35, 0x32, 0x33, 0x39, 0x31, 0x33, + 0x45, 0x46, 0x39, 0x38, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x32, 0x36, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x44, 0x30, + 0x35, 0x42, 0x39, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x43, 0x35, 0x42, 0x41, 0x34, 0x43, 0x34, 0x34, 0x46, 0x34, 0x30, 0x35, + 0x31, 0x35, 0x31, 0x44, 0x43, 0x45, 0x45, 0x41, 0x41, 0x44, 0x45, 0x34, + 0x31, 0x34, 0x30, 0x31, 0x46, 0x46, 0x45, 0x33, 0x37, 0x42, 0x37, 0x34, + 0x34, 0x31, 0x45, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x32, 0x37, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x43, 0x37, 0x38, 0x43, + 0x46, 0x37, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, + 0x32, 0x43, 0x37, 0x33, 0x44, 0x31, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x34, 0x41, 0x36, 0x31, 0x37, 0x30, 0x46, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x32, 0x37, 0x31, 0x39, 0x43, + 0x30, 0x41, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x33, 0x38, 0x34, 0x44, 0x36, 0x42, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x37, 0x32, 0x41, 0x43, 0x46, 0x30, 0x35, 0x38, + 0x34, 0x30, 0x0a, 0x32, 0x37, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x45, 0x33, 0x30, 0x34, 0x32, 0x46, 0x42, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x36, 0x42, 0x38, 0x45, 0x31, + 0x32, 0x35, 0x37, 0x34, 0x30, 0x41, 0x34, 0x45, 0x31, 0x32, 0x45, 0x31, + 0x30, 0x35, 0x46, 0x44, 0x36, 0x35, 0x33, 0x34, 0x30, 0x45, 0x43, 0x33, + 0x36, 0x39, 0x37, 0x46, 0x41, 0x34, 0x41, 0x30, 0x33, 0x35, 0x34, 0x34, + 0x30, 0x0a, 0x32, 0x37, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x45, 0x34, 0x41, 0x46, 0x34, 0x42, 0x31, 0x35, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x41, 0x35, 0x35, 0x34, 0x34, 0x44, + 0x34, 0x36, 0x34, 0x30, 0x43, 0x43, 0x42, 0x39, 0x43, 0x44, 0x44, 0x44, + 0x33, 0x31, 0x44, 0x33, 0x34, 0x36, 0x34, 0x30, 0x42, 0x30, 0x38, 0x32, + 0x35, 0x38, 0x42, 0x38, 0x30, 0x39, 0x39, 0x46, 0x33, 0x34, 0x34, 0x30, + 0x0a, 0x32, 0x37, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x43, 0x32, 0x42, 0x45, 0x42, 0x45, 0x39, 0x34, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x30, 0x46, 0x42, 0x44, 0x34, 0x35, 0x30, 0x32, + 0x30, 0x34, 0x30, 0x34, 0x42, 0x43, 0x34, 0x30, 0x45, 0x34, 0x42, 0x42, + 0x31, 0x34, 0x31, 0x34, 0x31, 0x34, 0x30, 0x42, 0x36, 0x32, 0x45, 0x41, + 0x41, 0x36, 0x44, 0x43, 0x41, 0x44, 0x30, 0x33, 0x41, 0x34, 0x30, 0x0a, + 0x32, 0x37, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x32, 0x38, 0x45, 0x46, 0x44, 0x44, 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x38, 0x41, 0x30, 0x42, 0x44, 0x35, 0x33, 0x33, 0x30, + 0x34, 0x30, 0x32, 0x39, 0x35, 0x34, 0x41, 0x41, 0x37, 0x32, 0x43, 0x45, + 0x36, 0x44, 0x33, 0x39, 0x34, 0x30, 0x36, 0x38, 0x37, 0x41, 0x37, 0x37, + 0x37, 0x37, 0x44, 0x31, 0x33, 0x44, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x32, + 0x37, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x45, + 0x37, 0x30, 0x33, 0x44, 0x45, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x41, 0x30, 0x39, 0x43, 0x39, 0x37, 0x43, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x45, 0x32, 0x44, 0x32, 0x46, + 0x32, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, + 0x42, 0x37, 0x31, 0x45, 0x32, 0x34, 0x43, 0x34, 0x30, 0x31, 0x30, 0x44, + 0x32, 0x31, 0x46, 0x33, 0x39, 0x39, 0x32, 0x34, 0x35, 0x34, 0x42, 0x34, + 0x30, 0x33, 0x30, 0x42, 0x38, 0x38, 0x36, 0x43, 0x36, 0x32, 0x38, 0x32, + 0x30, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x32, 0x37, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x36, 0x34, 0x36, 0x39, 0x42, 0x43, + 0x32, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x30, 0x38, + 0x42, 0x46, 0x32, 0x37, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x38, 0x36, 0x35, 0x34, 0x41, 0x30, 0x34, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x44, 0x31, 0x32, 0x36, 0x46, 0x46, + 0x34, 0x36, 0x34, 0x30, 0x33, 0x37, 0x36, 0x36, 0x43, 0x35, 0x44, 0x33, + 0x38, 0x33, 0x35, 0x42, 0x34, 0x43, 0x34, 0x30, 0x37, 0x31, 0x31, 0x42, + 0x42, 0x32, 0x34, 0x42, 0x30, 0x32, 0x32, 0x38, 0x34, 0x43, 0x34, 0x30, + 0x0a, 0x32, 0x37, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x38, 0x33, 0x37, 0x38, 0x46, 0x33, 0x30, 0x33, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x38, 0x35, 0x32, 0x30, 0x37, 0x37, 0x35, 0x33, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x43, 0x32, 0x46, + 0x44, 0x41, 0x33, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x38, 0x30, 0x44, 0x42, 0x31, 0x31, 0x31, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x36, 0x36, 0x32, 0x37, 0x41, 0x30, 0x45, 0x35, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x32, 0x44, 0x45, + 0x39, 0x38, 0x45, 0x31, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x33, 0x35, 0x43, 0x31, 0x44, 0x45, 0x30, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x36, 0x39, 0x33, 0x37, 0x41, 0x35, 0x33, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x31, 0x42, + 0x32, 0x33, 0x46, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x41, 0x46, 0x37, 0x39, 0x34, 0x39, 0x37, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x30, 0x39, 0x33, 0x45, 0x35, 0x41, 0x39, 0x34, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x42, 0x39, 0x37, + 0x32, 0x34, 0x33, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x36, 0x39, 0x41, 0x36, 0x42, 0x32, 0x33, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x43, 0x38, 0x33, 0x31, 0x33, 0x37, 0x38, 0x35, + 0x38, 0x34, 0x30, 0x0a, 0x32, 0x37, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x43, 0x30, 0x45, 0x34, 0x34, 0x35, 0x44, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x35, 0x31, 0x33, 0x32, + 0x34, 0x43, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x36, 0x33, 0x32, 0x46, 0x33, 0x46, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x42, 0x31, 0x31, 0x33, 0x34, 0x44, 0x31, 0x46, + 0x34, 0x30, 0x0a, 0x32, 0x37, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x33, 0x45, 0x37, 0x30, 0x44, 0x32, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x43, 0x39, 0x45, + 0x38, 0x34, 0x41, 0x34, 0x30, 0x39, 0x46, 0x43, 0x35, 0x39, 0x44, 0x30, + 0x41, 0x30, 0x37, 0x38, 0x32, 0x34, 0x30, 0x34, 0x30, 0x35, 0x42, 0x39, + 0x36, 0x43, 0x44, 0x33, 0x45, 0x41, 0x39, 0x41, 0x45, 0x35, 0x32, 0x34, + 0x30, 0x0a, 0x32, 0x38, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x34, 0x41, 0x37, 0x32, 0x45, 0x33, 0x45, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x46, 0x43, 0x37, 0x36, 0x43, 0x34, + 0x34, 0x46, 0x34, 0x30, 0x34, 0x39, 0x31, 0x44, 0x31, 0x42, 0x38, 0x35, + 0x46, 0x46, 0x36, 0x33, 0x34, 0x41, 0x34, 0x30, 0x41, 0x43, 0x41, 0x41, + 0x39, 0x41, 0x44, 0x43, 0x39, 0x30, 0x41, 0x43, 0x33, 0x38, 0x34, 0x30, + 0x0a, 0x32, 0x38, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x30, 0x38, 0x37, 0x34, 0x45, 0x33, 0x44, 0x33, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x34, 0x41, 0x37, 0x41, 0x38, 0x32, 0x43, 0x34, + 0x31, 0x34, 0x30, 0x33, 0x38, 0x33, 0x35, 0x38, 0x38, 0x42, 0x45, 0x45, + 0x30, 0x35, 0x43, 0x35, 0x33, 0x34, 0x30, 0x36, 0x33, 0x44, 0x36, 0x30, + 0x39, 0x42, 0x44, 0x33, 0x32, 0x39, 0x38, 0x34, 0x44, 0x34, 0x30, 0x0a, + 0x32, 0x38, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, + 0x36, 0x39, 0x32, 0x35, 0x41, 0x36, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x38, 0x32, 0x38, 0x41, 0x36, 0x30, 0x43, 0x33, 0x42, + 0x34, 0x30, 0x36, 0x30, 0x42, 0x41, 0x34, 0x31, 0x35, 0x41, 0x45, 0x44, + 0x42, 0x37, 0x35, 0x32, 0x34, 0x30, 0x34, 0x39, 0x31, 0x33, 0x36, 0x44, + 0x33, 0x38, 0x30, 0x35, 0x36, 0x30, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x32, + 0x38, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x46, + 0x35, 0x35, 0x31, 0x30, 0x44, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x30, 0x44, 0x44, 0x38, 0x42, 0x43, 0x33, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, 0x31, 0x42, 0x45, 0x33, 0x34, + 0x43, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x45, + 0x45, 0x34, 0x32, 0x34, 0x37, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x30, 0x32, 0x31, 0x38, 0x39, 0x34, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x35, 0x41, 0x32, 0x35, + 0x45, 0x46, 0x30, 0x33, 0x46, 0x0a, 0x32, 0x38, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x39, 0x39, 0x45, 0x34, 0x44, 0x33, + 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x42, 0x45, + 0x39, 0x44, 0x41, 0x46, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x41, 0x46, 0x31, 0x37, 0x44, 0x32, 0x36, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, 0x36, 0x37, 0x31, 0x37, 0x43, 0x35, + 0x34, 0x37, 0x34, 0x30, 0x0a, 0x32, 0x38, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x32, 0x33, 0x31, 0x43, 0x38, 0x41, 0x31, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x34, 0x46, 0x31, + 0x38, 0x38, 0x42, 0x34, 0x37, 0x34, 0x30, 0x35, 0x35, 0x35, 0x37, 0x46, + 0x41, 0x38, 0x39, 0x38, 0x43, 0x42, 0x39, 0x33, 0x34, 0x34, 0x30, 0x35, + 0x37, 0x44, 0x44, 0x31, 0x43, 0x31, 0x38, 0x41, 0x30, 0x31, 0x32, 0x34, + 0x45, 0x34, 0x30, 0x0a, 0x32, 0x38, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x34, 0x46, 0x46, 0x41, 0x42, 0x33, 0x36, 0x34, 0x45, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x45, 0x33, 0x42, 0x36, 0x35, + 0x42, 0x43, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x45, + 0x45, 0x34, 0x45, 0x41, 0x45, 0x42, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x41, 0x39, 0x33, 0x45, 0x35, 0x33, + 0x34, 0x30, 0x0a, 0x32, 0x38, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x45, 0x34, 0x32, 0x43, 0x45, 0x45, 0x33, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x34, 0x31, 0x34, 0x38, 0x31, + 0x35, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x44, + 0x38, 0x33, 0x44, 0x41, 0x45, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x34, 0x35, 0x45, 0x42, 0x31, 0x33, 0x30, 0x35, 0x32, 0x34, + 0x30, 0x0a, 0x32, 0x38, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x36, 0x45, 0x32, 0x30, 0x33, 0x30, 0x35, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x45, 0x39, 0x32, 0x42, 0x37, 0x32, + 0x35, 0x32, 0x34, 0x30, 0x44, 0x36, 0x30, 0x44, 0x42, 0x33, 0x36, 0x30, + 0x31, 0x31, 0x32, 0x45, 0x34, 0x45, 0x34, 0x30, 0x30, 0x46, 0x36, 0x42, + 0x32, 0x38, 0x35, 0x45, 0x35, 0x46, 0x30, 0x33, 0x35, 0x32, 0x34, 0x30, + 0x0a, 0x32, 0x38, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x32, 0x37, 0x45, 0x39, 0x39, 0x30, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x43, 0x44, 0x42, 0x45, 0x42, 0x32, 0x39, 0x34, + 0x31, 0x34, 0x30, 0x37, 0x38, 0x35, 0x35, 0x44, 0x46, 0x44, 0x33, 0x37, + 0x33, 0x35, 0x31, 0x33, 0x36, 0x34, 0x30, 0x35, 0x39, 0x45, 0x35, 0x38, + 0x37, 0x35, 0x36, 0x39, 0x33, 0x44, 0x34, 0x34, 0x46, 0x34, 0x30, 0x0a, + 0x32, 0x39, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x37, 0x31, 0x30, 0x46, 0x31, 0x39, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x34, 0x34, 0x37, 0x44, 0x30, 0x45, 0x42, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x46, 0x43, 0x32, + 0x30, 0x45, 0x32, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, + 0x31, 0x33, 0x44, 0x35, 0x43, 0x39, 0x34, 0x41, 0x34, 0x30, 0x39, 0x42, + 0x37, 0x39, 0x34, 0x34, 0x30, 0x41, 0x39, 0x32, 0x30, 0x46, 0x34, 0x30, + 0x34, 0x30, 0x34, 0x38, 0x33, 0x32, 0x30, 0x35, 0x30, 0x39, 0x38, 0x41, + 0x37, 0x33, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x32, 0x39, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x37, 0x44, 0x42, 0x43, 0x42, + 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x37, 0x36, 0x42, 0x38, 0x34, 0x45, 0x42, 0x33, 0x46, 0x39, 0x44, 0x35, + 0x30, 0x35, 0x38, 0x33, 0x31, 0x37, 0x38, 0x32, 0x32, 0x35, 0x31, 0x34, + 0x30, 0x38, 0x30, 0x33, 0x37, 0x39, 0x33, 0x42, 0x35, 0x42, 0x37, 0x43, + 0x31, 0x33, 0x46, 0x34, 0x30, 0x0a, 0x32, 0x39, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x35, 0x37, 0x36, 0x33, 0x30, 0x36, + 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x46, 0x38, + 0x46, 0x36, 0x39, 0x43, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x43, 0x43, 0x46, 0x31, 0x46, 0x31, 0x38, 0x34, 0x44, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x32, 0x36, 0x31, 0x44, 0x38, 0x38, 0x36, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x41, 0x31, + 0x30, 0x32, 0x41, 0x30, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x30, 0x30, 0x41, 0x37, 0x41, 0x38, 0x39, 0x31, 0x31, 0x34, 0x30, + 0x0a, 0x32, 0x39, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x41, 0x46, 0x39, 0x44, 0x41, 0x45, 0x31, 0x35, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x38, 0x35, 0x34, 0x30, 0x34, 0x46, 0x42, 0x34, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x41, 0x37, 0x32, + 0x42, 0x31, 0x35, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x34, 0x45, 0x39, 0x38, 0x38, 0x32, 0x32, 0x31, 0x34, 0x30, 0x33, + 0x43, 0x33, 0x35, 0x39, 0x36, 0x45, 0x43, 0x30, 0x37, 0x30, 0x42, 0x34, + 0x44, 0x34, 0x30, 0x46, 0x43, 0x42, 0x41, 0x37, 0x41, 0x45, 0x42, 0x41, + 0x32, 0x30, 0x32, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x32, 0x39, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x37, 0x45, 0x43, 0x35, + 0x41, 0x42, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x45, 0x37, 0x36, 0x37, 0x44, 0x43, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x36, 0x46, 0x41, 0x38, 0x33, 0x37, 0x38, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x42, 0x44, 0x41, 0x33, + 0x33, 0x39, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, + 0x36, 0x45, 0x43, 0x36, 0x43, 0x43, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x31, 0x45, 0x39, 0x41, 0x34, 0x33, 0x30, 0x46, + 0x34, 0x30, 0x43, 0x45, 0x36, 0x36, 0x33, 0x32, 0x43, 0x39, 0x39, 0x46, + 0x43, 0x32, 0x35, 0x32, 0x34, 0x30, 0x33, 0x36, 0x30, 0x46, 0x42, 0x46, + 0x41, 0x31, 0x33, 0x31, 0x37, 0x35, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x32, + 0x39, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x34, + 0x36, 0x30, 0x41, 0x37, 0x31, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x45, 0x32, 0x36, 0x30, 0x30, 0x38, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x46, 0x31, 0x37, 0x37, 0x30, + 0x34, 0x30, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x36, + 0x41, 0x38, 0x30, 0x31, 0x42, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x30, 0x31, 0x41, 0x30, 0x32, 0x33, 0x38, 0x32, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x45, 0x41, 0x33, 0x32, 0x43, + 0x37, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x42, + 0x34, 0x30, 0x42, 0x33, 0x42, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x34, 0x32, 0x36, 0x35, 0x30, 0x34, 0x43, 0x34, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x45, 0x31, 0x31, 0x42, 0x37, + 0x36, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x32, + 0x39, 0x38, 0x30, 0x32, 0x41, 0x34, 0x35, 0x34, 0x30, 0x0a, 0x32, 0x39, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x33, + 0x36, 0x32, 0x35, 0x46, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x44, 0x30, 0x35, 0x45, 0x39, 0x34, 0x37, 0x30, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x39, 0x46, 0x42, 0x43, 0x39, 0x43, + 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x38, 0x35, + 0x38, 0x39, 0x36, 0x41, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x38, 0x36, 0x33, 0x42, 0x39, 0x39, 0x45, 0x33, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x32, 0x45, 0x33, 0x32, 0x46, 0x42, + 0x31, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x42, + 0x36, 0x41, 0x32, 0x31, 0x31, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x43, 0x32, 0x30, 0x32, 0x33, 0x31, 0x43, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x46, 0x37, 0x46, 0x43, 0x45, + 0x32, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, + 0x46, 0x45, 0x42, 0x31, 0x45, 0x45, 0x33, 0x46, 0x0a, 0x32, 0x39, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x33, 0x34, 0x32, + 0x39, 0x44, 0x36, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x43, 0x46, 0x39, 0x42, 0x33, 0x43, 0x38, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x34, 0x44, 0x46, 0x31, 0x45, 0x31, 0x37, 0x34, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x38, 0x33, + 0x30, 0x45, 0x36, 0x31, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x30, 0x45, 0x46, 0x44, 0x45, 0x33, 0x35, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x35, 0x41, 0x31, 0x43, 0x44, + 0x34, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, 0x36, 0x34, 0x32, + 0x44, 0x39, 0x39, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x34, 0x45, 0x30, 0x42, 0x39, 0x41, 0x36, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x37, 0x37, 0x41, 0x36, 0x32, 0x46, 0x34, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x44, 0x35, 0x31, + 0x42, 0x38, 0x35, 0x35, 0x36, 0x34, 0x30, 0x0a, 0x32, 0x39, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x46, 0x36, 0x45, 0x44, + 0x44, 0x46, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, + 0x33, 0x46, 0x39, 0x43, 0x41, 0x30, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x44, 0x37, 0x43, 0x30, 0x35, 0x34, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x38, 0x33, + 0x39, 0x43, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x41, 0x41, 0x45, 0x35, 0x45, 0x42, 0x30, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x41, 0x32, 0x39, 0x45, 0x36, 0x41, 0x38, 0x35, 0x31, + 0x34, 0x30, 0x0a, 0x32, 0x39, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x43, 0x38, 0x34, 0x33, 0x45, 0x30, 0x39, 0x34, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x34, 0x38, 0x37, 0x44, 0x42, + 0x46, 0x32, 0x34, 0x34, 0x30, 0x35, 0x30, 0x33, 0x44, 0x38, 0x44, 0x36, + 0x30, 0x32, 0x38, 0x32, 0x34, 0x34, 0x39, 0x34, 0x30, 0x35, 0x36, 0x41, + 0x42, 0x45, 0x43, 0x44, 0x46, 0x34, 0x45, 0x32, 0x42, 0x34, 0x30, 0x34, + 0x30, 0x0a, 0x33, 0x30, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x43, 0x41, 0x39, 0x30, 0x37, 0x42, 0x37, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x32, 0x32, 0x39, 0x34, 0x43, 0x33, + 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x35, 0x45, + 0x41, 0x35, 0x36, 0x32, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x43, 0x30, 0x34, 0x32, 0x34, 0x43, 0x42, 0x35, 0x38, 0x34, 0x30, + 0x42, 0x38, 0x34, 0x41, 0x37, 0x33, 0x37, 0x44, 0x36, 0x41, 0x42, 0x33, + 0x34, 0x37, 0x34, 0x30, 0x45, 0x37, 0x36, 0x37, 0x44, 0x43, 0x42, 0x42, + 0x42, 0x30, 0x33, 0x33, 0x35, 0x35, 0x34, 0x30, 0x0a, 0x33, 0x30, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x32, 0x46, 0x36, 0x31, + 0x46, 0x44, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x45, 0x30, 0x30, 0x43, 0x38, 0x38, 0x35, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x41, 0x37, 0x31, 0x32, 0x41, 0x34, 0x35, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x35, 0x35, 0x35, + 0x32, 0x34, 0x44, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x30, 0x31, 0x45, 0x46, 0x34, 0x31, 0x38, 0x32, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x32, 0x43, 0x43, 0x32, 0x45, 0x46, 0x34, 0x35, + 0x31, 0x34, 0x30, 0x0a, 0x33, 0x30, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x41, 0x31, 0x35, 0x42, 0x34, 0x30, 0x32, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x45, 0x38, 0x33, 0x36, + 0x36, 0x32, 0x35, 0x38, 0x34, 0x30, 0x45, 0x38, 0x36, 0x37, 0x42, 0x36, + 0x42, 0x30, 0x33, 0x41, 0x32, 0x42, 0x34, 0x32, 0x34, 0x30, 0x35, 0x31, + 0x42, 0x44, 0x46, 0x41, 0x39, 0x46, 0x45, 0x36, 0x31, 0x39, 0x35, 0x30, + 0x34, 0x30, 0x0a, 0x33, 0x30, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x30, 0x37, 0x30, 0x35, 0x44, 0x35, 0x41, 0x33, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, 0x32, 0x43, 0x46, 0x32, 0x33, + 0x37, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, + 0x41, 0x30, 0x36, 0x36, 0x41, 0x33, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x38, 0x36, 0x42, 0x41, 0x30, 0x46, 0x35, 0x35, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x38, 0x35, 0x35, 0x30, 0x41, + 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x41, 0x33, 0x30, 0x39, 0x34, 0x30, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x36, 0x36, 0x43, 0x36, 0x38, 0x37, 0x42, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x45, 0x43, 0x46, 0x35, 0x44, + 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x44, + 0x42, 0x46, 0x33, 0x33, 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x41, 0x46, 0x30, 0x38, 0x36, 0x44, 0x45, 0x35, 0x37, 0x34, + 0x30, 0x0a, 0x33, 0x30, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x36, 0x39, 0x34, 0x33, 0x30, 0x46, 0x35, 0x34, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x34, 0x39, 0x33, 0x33, 0x34, + 0x32, 0x32, 0x34, 0x30, 0x38, 0x32, 0x42, 0x44, 0x38, 0x36, 0x37, 0x34, + 0x35, 0x37, 0x39, 0x44, 0x34, 0x44, 0x34, 0x30, 0x36, 0x41, 0x44, 0x32, + 0x46, 0x34, 0x34, 0x35, 0x39, 0x37, 0x38, 0x37, 0x32, 0x46, 0x34, 0x30, + 0x0a, 0x33, 0x30, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x42, 0x36, 0x33, 0x36, 0x35, 0x31, 0x30, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x38, 0x43, 0x42, 0x46, 0x36, 0x42, 0x39, 0x35, + 0x35, 0x34, 0x30, 0x37, 0x34, 0x39, 0x41, 0x41, 0x44, 0x42, 0x45, 0x31, + 0x35, 0x39, 0x41, 0x32, 0x46, 0x34, 0x30, 0x38, 0x33, 0x39, 0x44, 0x37, + 0x46, 0x41, 0x36, 0x43, 0x31, 0x32, 0x46, 0x33, 0x43, 0x34, 0x30, 0x0a, + 0x33, 0x30, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x42, 0x46, 0x34, 0x38, 0x44, 0x37, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x30, 0x36, 0x30, 0x35, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x41, 0x38, 0x42, 0x33, 0x38, + 0x42, 0x42, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, + 0x38, 0x31, 0x32, 0x43, 0x45, 0x41, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x34, 0x35, 0x38, 0x36, 0x33, 0x41, 0x37, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x44, 0x45, 0x36, 0x34, + 0x30, 0x30, 0x33, 0x34, 0x34, 0x30, 0x44, 0x38, 0x33, 0x33, 0x35, 0x34, + 0x32, 0x45, 0x30, 0x46, 0x43, 0x30, 0x35, 0x37, 0x34, 0x30, 0x44, 0x31, + 0x42, 0x44, 0x39, 0x44, 0x34, 0x39, 0x45, 0x33, 0x43, 0x36, 0x33, 0x35, + 0x34, 0x30, 0x0a, 0x33, 0x30, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x45, 0x39, 0x34, 0x31, 0x31, 0x39, 0x44, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x34, 0x42, 0x35, 0x32, 0x33, + 0x46, 0x31, 0x45, 0x34, 0x30, 0x39, 0x45, 0x30, 0x30, 0x42, 0x33, 0x42, + 0x30, 0x46, 0x41, 0x36, 0x39, 0x34, 0x43, 0x34, 0x30, 0x36, 0x34, 0x44, + 0x44, 0x31, 0x38, 0x38, 0x41, 0x42, 0x31, 0x35, 0x36, 0x34, 0x43, 0x34, + 0x30, 0x0a, 0x33, 0x30, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x41, 0x39, 0x30, 0x46, 0x42, 0x45, 0x41, 0x35, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x30, 0x35, 0x30, 0x30, 0x46, 0x45, + 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x33, 0x46, + 0x42, 0x45, 0x35, 0x42, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x39, 0x34, 0x34, 0x35, 0x36, 0x44, 0x35, 0x30, 0x34, 0x30, + 0x0a, 0x33, 0x30, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x43, 0x36, 0x46, 0x39, 0x30, 0x31, 0x31, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x30, 0x32, 0x44, 0x39, 0x43, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x35, 0x46, 0x31, + 0x44, 0x34, 0x42, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x30, 0x37, 0x32, 0x45, 0x39, 0x45, 0x35, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x38, 0x43, 0x31, 0x46, 0x33, 0x45, 0x41, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x46, 0x43, + 0x31, 0x32, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x36, 0x36, 0x32, 0x33, 0x34, 0x30, 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x38, 0x33, 0x37, 0x42, 0x30, 0x32, + 0x36, 0x34, 0x30, 0x0a, 0x33, 0x31, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x34, 0x41, 0x44, 0x31, 0x32, 0x36, 0x43, 0x34, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x34, 0x34, 0x33, 0x31, + 0x41, 0x39, 0x31, 0x41, 0x34, 0x30, 0x39, 0x44, 0x45, 0x31, 0x45, 0x37, + 0x31, 0x33, 0x32, 0x45, 0x39, 0x37, 0x35, 0x35, 0x34, 0x30, 0x31, 0x45, + 0x33, 0x32, 0x42, 0x37, 0x46, 0x30, 0x41, 0x41, 0x42, 0x41, 0x34, 0x31, + 0x34, 0x30, 0x0a, 0x33, 0x31, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x38, 0x36, 0x39, 0x45, 0x36, 0x37, 0x43, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x35, 0x39, 0x45, 0x38, + 0x32, 0x34, 0x45, 0x34, 0x30, 0x45, 0x33, 0x41, 0x32, 0x39, 0x41, 0x41, + 0x35, 0x33, 0x39, 0x43, 0x31, 0x34, 0x46, 0x34, 0x30, 0x34, 0x43, 0x39, + 0x43, 0x38, 0x34, 0x32, 0x35, 0x37, 0x39, 0x43, 0x42, 0x34, 0x37, 0x34, + 0x30, 0x0a, 0x33, 0x31, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x45, 0x31, 0x36, 0x39, 0x31, 0x43, 0x46, 0x35, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x42, 0x39, 0x35, 0x33, 0x39, 0x45, + 0x34, 0x34, 0x34, 0x30, 0x34, 0x31, 0x45, 0x31, 0x41, 0x45, 0x35, 0x39, + 0x45, 0x38, 0x35, 0x35, 0x34, 0x30, 0x34, 0x30, 0x39, 0x43, 0x34, 0x35, + 0x33, 0x42, 0x39, 0x33, 0x35, 0x37, 0x32, 0x31, 0x32, 0x44, 0x34, 0x30, + 0x0a, 0x33, 0x31, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x36, 0x37, 0x42, 0x34, 0x43, 0x45, 0x46, 0x32, 0x33, 0x46, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x43, 0x39, 0x37, 0x33, 0x30, 0x43, 0x30, 0x34, + 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x41, 0x30, 0x46, 0x44, + 0x45, 0x32, 0x34, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x43, 0x35, 0x33, 0x41, 0x36, 0x42, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x38, 0x42, 0x38, 0x41, 0x39, 0x38, 0x43, 0x34, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x34, 0x36, 0x42, 0x43, + 0x39, 0x30, 0x46, 0x35, 0x34, 0x34, 0x30, 0x0a, 0x33, 0x31, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x46, 0x38, 0x45, 0x33, + 0x37, 0x45, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, + 0x35, 0x35, 0x44, 0x32, 0x46, 0x42, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x43, 0x39, 0x44, 0x36, 0x41, 0x44, 0x38, 0x34, 0x45, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x46, 0x39, 0x45, + 0x41, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x32, + 0x34, 0x30, 0x31, 0x32, 0x41, 0x32, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x30, 0x43, 0x33, 0x34, 0x38, 0x31, 0x32, 0x32, 0x43, + 0x34, 0x30, 0x0a, 0x33, 0x31, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x41, 0x46, 0x34, 0x36, 0x45, 0x33, 0x34, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x45, 0x42, 0x45, 0x35, 0x41, + 0x32, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x32, + 0x42, 0x39, 0x37, 0x35, 0x42, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x35, 0x43, 0x31, 0x33, 0x34, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x30, 0x41, 0x41, 0x38, 0x33, + 0x44, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x32, + 0x30, 0x38, 0x35, 0x36, 0x36, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x34, 0x31, 0x30, 0x31, 0x34, 0x36, 0x42, 0x34, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x41, 0x38, 0x42, 0x42, + 0x35, 0x30, 0x30, 0x34, 0x30, 0x0a, 0x33, 0x31, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x34, 0x35, 0x36, 0x30, 0x43, 0x39, + 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x31, 0x33, + 0x31, 0x36, 0x30, 0x32, 0x35, 0x30, 0x34, 0x30, 0x45, 0x41, 0x30, 0x35, + 0x45, 0x34, 0x38, 0x31, 0x37, 0x30, 0x41, 0x44, 0x35, 0x34, 0x34, 0x30, + 0x42, 0x30, 0x42, 0x37, 0x37, 0x37, 0x39, 0x43, 0x38, 0x32, 0x46, 0x32, + 0x34, 0x41, 0x34, 0x30, 0x0a, 0x33, 0x31, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x36, 0x46, 0x32, 0x43, 0x39, 0x31, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x41, 0x36, 0x31, + 0x43, 0x37, 0x44, 0x33, 0x36, 0x34, 0x30, 0x33, 0x35, 0x31, 0x39, 0x36, + 0x42, 0x41, 0x45, 0x35, 0x32, 0x31, 0x42, 0x33, 0x30, 0x34, 0x30, 0x42, + 0x35, 0x37, 0x39, 0x45, 0x33, 0x34, 0x36, 0x33, 0x39, 0x42, 0x30, 0x34, + 0x33, 0x34, 0x30, 0x0a, 0x33, 0x31, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x43, 0x43, 0x46, 0x33, 0x34, 0x46, 0x32, 0x35, 0x34, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x45, 0x43, 0x31, 0x42, 0x36, + 0x39, 0x36, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x39, 0x41, 0x33, 0x39, 0x45, 0x37, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x32, 0x39, 0x32, 0x41, 0x37, 0x37, 0x34, 0x42, + 0x34, 0x30, 0x34, 0x45, 0x31, 0x31, 0x36, 0x44, 0x36, 0x42, 0x38, 0x36, + 0x39, 0x30, 0x33, 0x44, 0x34, 0x30, 0x44, 0x43, 0x44, 0x42, 0x42, 0x46, + 0x46, 0x46, 0x42, 0x44, 0x36, 0x35, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x33, + 0x31, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x30, + 0x31, 0x43, 0x45, 0x41, 0x44, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x41, 0x41, 0x31, 0x34, 0x38, 0x42, 0x33, 0x35, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x33, 0x45, 0x45, 0x41, + 0x30, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x46, + 0x46, 0x34, 0x34, 0x46, 0x38, 0x35, 0x38, 0x34, 0x30, 0x43, 0x35, 0x43, + 0x37, 0x35, 0x45, 0x30, 0x45, 0x46, 0x45, 0x43, 0x45, 0x34, 0x32, 0x34, + 0x30, 0x43, 0x33, 0x43, 0x44, 0x30, 0x34, 0x44, 0x31, 0x42, 0x41, 0x30, + 0x41, 0x34, 0x42, 0x34, 0x30, 0x0a, 0x33, 0x32, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x34, 0x46, 0x31, 0x46, 0x41, 0x42, + 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x36, 0x33, + 0x30, 0x46, 0x44, 0x36, 0x32, 0x31, 0x34, 0x30, 0x33, 0x43, 0x33, 0x35, + 0x45, 0x45, 0x37, 0x34, 0x32, 0x32, 0x44, 0x38, 0x34, 0x42, 0x34, 0x30, + 0x37, 0x30, 0x38, 0x38, 0x44, 0x31, 0x43, 0x43, 0x39, 0x39, 0x35, 0x42, + 0x34, 0x39, 0x34, 0x30, 0x0a, 0x33, 0x32, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x37, 0x37, 0x33, 0x31, 0x43, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x37, 0x45, 0x37, + 0x39, 0x33, 0x38, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x38, 0x31, 0x37, 0x36, 0x38, 0x32, 0x35, 0x33, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x32, 0x32, 0x34, 0x46, 0x33, 0x44, 0x34, 0x35, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x34, 0x35, + 0x33, 0x42, 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x35, 0x45, 0x43, 0x43, 0x43, 0x31, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x34, 0x41, 0x36, 0x33, 0x36, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x35, 0x44, + 0x38, 0x37, 0x35, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x33, 0x32, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x43, 0x43, 0x34, 0x34, + 0x43, 0x37, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x34, + 0x46, 0x41, 0x41, 0x41, 0x37, 0x39, 0x34, 0x31, 0x34, 0x30, 0x46, 0x33, + 0x37, 0x41, 0x43, 0x31, 0x41, 0x42, 0x34, 0x37, 0x35, 0x43, 0x34, 0x42, + 0x34, 0x30, 0x31, 0x33, 0x30, 0x46, 0x46, 0x46, 0x36, 0x33, 0x42, 0x30, + 0x42, 0x44, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x33, 0x32, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x32, 0x38, 0x44, 0x38, 0x35, + 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x33, + 0x33, 0x33, 0x31, 0x45, 0x42, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x34, 0x36, 0x33, 0x32, 0x34, 0x41, 0x32, 0x35, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x34, 0x37, 0x35, 0x39, 0x44, 0x31, + 0x46, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x33, 0x32, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x41, 0x30, 0x37, 0x37, 0x43, 0x31, + 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x36, 0x39, + 0x42, 0x34, 0x37, 0x37, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x45, 0x35, 0x39, 0x33, 0x42, 0x39, 0x35, 0x35, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x33, 0x31, 0x34, 0x34, 0x31, 0x35, + 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x32, 0x36, + 0x42, 0x36, 0x44, 0x34, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x32, 0x31, 0x38, 0x36, 0x44, 0x38, 0x33, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x45, 0x41, 0x34, 0x41, 0x30, + 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x45, 0x41, + 0x35, 0x42, 0x42, 0x30, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x42, 0x37, 0x44, 0x34, 0x46, 0x45, 0x31, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x33, 0x31, 0x41, 0x31, 0x31, + 0x33, 0x38, 0x34, 0x30, 0x0a, 0x33, 0x32, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x36, 0x36, 0x34, 0x39, 0x42, 0x46, 0x35, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x33, 0x35, 0x33, + 0x35, 0x30, 0x37, 0x34, 0x46, 0x34, 0x30, 0x31, 0x33, 0x31, 0x34, 0x43, + 0x44, 0x35, 0x43, 0x44, 0x37, 0x35, 0x39, 0x35, 0x32, 0x34, 0x30, 0x44, + 0x41, 0x45, 0x37, 0x44, 0x44, 0x42, 0x33, 0x39, 0x39, 0x39, 0x44, 0x35, + 0x31, 0x34, 0x30, 0x0a, 0x33, 0x32, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x38, 0x41, 0x32, 0x38, 0x43, 0x36, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x32, 0x37, 0x31, 0x34, + 0x35, 0x45, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x38, 0x32, 0x31, 0x44, 0x44, 0x37, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x36, 0x43, 0x36, 0x34, 0x37, 0x32, 0x41, 0x35, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x32, 0x41, 0x44, 0x33, + 0x42, 0x35, 0x31, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, + 0x30, 0x45, 0x35, 0x42, 0x45, 0x36, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x33, + 0x32, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x34, 0x35, 0x35, 0x35, 0x46, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x30, 0x30, 0x42, 0x45, 0x33, 0x39, 0x31, 0x32, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x31, 0x32, 0x43, 0x41, 0x37, + 0x43, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x42, + 0x42, 0x41, 0x39, 0x30, 0x44, 0x34, 0x38, 0x34, 0x30, 0x35, 0x42, 0x41, + 0x41, 0x33, 0x36, 0x36, 0x42, 0x35, 0x39, 0x42, 0x45, 0x35, 0x32, 0x34, + 0x30, 0x42, 0x39, 0x31, 0x37, 0x34, 0x41, 0x31, 0x35, 0x46, 0x45, 0x41, + 0x42, 0x34, 0x39, 0x34, 0x30, 0x0a, 0x33, 0x32, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x43, 0x32, 0x30, 0x35, 0x41, 0x37, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x38, 0x38, + 0x38, 0x44, 0x33, 0x42, 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x45, 0x37, 0x43, 0x43, 0x38, 0x46, 0x38, 0x33, 0x46, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x42, 0x41, 0x34, 0x30, 0x35, 0x35, + 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x41, 0x36, 0x31, + 0x44, 0x35, 0x37, 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x36, 0x38, 0x46, 0x46, 0x38, 0x36, 0x36, 0x35, 0x36, 0x34, 0x30, + 0x0a, 0x33, 0x32, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x32, 0x46, 0x38, 0x41, 0x35, 0x46, 0x44, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x45, 0x34, 0x45, 0x43, 0x43, 0x42, 0x33, 0x35, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, 0x45, 0x44, 0x37, + 0x38, 0x46, 0x39, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x41, 0x36, 0x32, 0x45, 0x42, 0x35, 0x33, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x36, 0x33, 0x31, 0x46, 0x34, 0x33, 0x46, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, 0x36, 0x37, 0x36, + 0x39, 0x36, 0x34, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x38, 0x39, 0x45, 0x46, 0x45, 0x44, 0x42, 0x33, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x36, 0x33, 0x42, 0x37, 0x39, 0x39, 0x37, 0x35, + 0x37, 0x34, 0x30, 0x0a, 0x33, 0x33, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x38, 0x36, 0x45, 0x34, 0x37, 0x36, 0x31, 0x35, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x41, 0x30, 0x39, 0x42, + 0x42, 0x35, 0x46, 0x30, 0x33, 0x46, 0x35, 0x46, 0x43, 0x41, 0x32, 0x43, + 0x44, 0x41, 0x46, 0x36, 0x32, 0x38, 0x32, 0x32, 0x34, 0x30, 0x37, 0x34, + 0x38, 0x31, 0x43, 0x31, 0x34, 0x44, 0x43, 0x39, 0x34, 0x46, 0x34, 0x30, + 0x34, 0x30, 0x0a, 0x33, 0x33, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x35, 0x37, 0x38, 0x32, 0x42, 0x36, 0x33, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x30, 0x39, 0x35, 0x38, 0x34, + 0x46, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x30, + 0x38, 0x43, 0x32, 0x44, 0x45, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x38, 0x34, 0x38, 0x34, 0x45, 0x42, 0x36, 0x34, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, 0x43, 0x35, 0x44, 0x46, + 0x36, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x43, + 0x38, 0x32, 0x37, 0x30, 0x44, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x38, 0x32, 0x46, 0x39, 0x32, 0x37, 0x43, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x41, 0x35, 0x46, 0x38, 0x38, + 0x33, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x33, 0x33, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x34, 0x45, 0x38, 0x33, 0x34, 0x41, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x39, 0x39, + 0x39, 0x32, 0x46, 0x36, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x36, 0x33, 0x46, 0x30, 0x46, 0x37, 0x37, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x44, 0x35, 0x33, 0x37, 0x36, 0x34, + 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x45, 0x39, + 0x30, 0x38, 0x44, 0x33, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x30, 0x34, 0x33, 0x46, 0x35, 0x39, 0x35, 0x34, 0x44, 0x34, 0x30, + 0x0a, 0x33, 0x33, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x38, 0x36, 0x41, 0x45, 0x36, 0x34, 0x33, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x32, 0x34, 0x39, 0x46, 0x41, 0x30, 0x31, 0x35, + 0x35, 0x34, 0x30, 0x33, 0x32, 0x32, 0x33, 0x33, 0x39, 0x30, 0x38, 0x41, + 0x30, 0x34, 0x35, 0x34, 0x43, 0x34, 0x30, 0x31, 0x37, 0x46, 0x42, 0x45, + 0x42, 0x30, 0x41, 0x34, 0x41, 0x45, 0x30, 0x35, 0x31, 0x34, 0x30, 0x0a, + 0x33, 0x33, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, + 0x33, 0x44, 0x38, 0x33, 0x35, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x43, 0x34, 0x30, 0x36, 0x42, 0x34, 0x39, 0x34, 0x34, + 0x34, 0x30, 0x39, 0x45, 0x42, 0x35, 0x31, 0x44, 0x37, 0x36, 0x37, 0x38, + 0x37, 0x37, 0x34, 0x35, 0x34, 0x30, 0x38, 0x41, 0x46, 0x36, 0x32, 0x42, + 0x41, 0x35, 0x32, 0x30, 0x45, 0x41, 0x34, 0x42, 0x34, 0x30, 0x0a, 0x33, + 0x33, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x36, + 0x44, 0x37, 0x42, 0x37, 0x34, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x44, 0x43, 0x38, 0x44, 0x30, 0x34, 0x32, 0x35, 0x34, + 0x30, 0x46, 0x45, 0x42, 0x31, 0x44, 0x46, 0x41, 0x36, 0x44, 0x42, 0x32, + 0x45, 0x35, 0x30, 0x34, 0x30, 0x35, 0x43, 0x39, 0x43, 0x39, 0x36, 0x35, + 0x45, 0x31, 0x41, 0x43, 0x42, 0x33, 0x41, 0x34, 0x30, 0x0a, 0x33, 0x33, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x32, + 0x39, 0x30, 0x44, 0x33, 0x32, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x43, 0x34, 0x45, 0x39, 0x32, 0x30, 0x43, 0x34, 0x32, 0x34, 0x30, + 0x32, 0x35, 0x36, 0x38, 0x39, 0x31, 0x35, 0x46, 0x36, 0x30, 0x39, 0x36, + 0x33, 0x43, 0x34, 0x30, 0x33, 0x34, 0x46, 0x34, 0x34, 0x34, 0x33, 0x41, + 0x38, 0x42, 0x38, 0x30, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x33, 0x33, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x38, 0x30, 0x41, + 0x32, 0x32, 0x42, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x38, 0x35, 0x35, 0x34, 0x38, 0x31, 0x46, 0x34, 0x41, 0x34, 0x30, 0x37, + 0x38, 0x35, 0x45, 0x38, 0x35, 0x33, 0x42, 0x36, 0x30, 0x38, 0x43, 0x32, + 0x45, 0x34, 0x30, 0x42, 0x45, 0x43, 0x39, 0x43, 0x33, 0x44, 0x33, 0x35, + 0x36, 0x32, 0x45, 0x34, 0x45, 0x34, 0x30, 0x0a, 0x33, 0x33, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x44, 0x35, 0x36, 0x46, + 0x44, 0x37, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, + 0x44, 0x39, 0x44, 0x36, 0x34, 0x33, 0x35, 0x32, 0x34, 0x30, 0x45, 0x42, + 0x41, 0x37, 0x33, 0x31, 0x37, 0x39, 0x46, 0x31, 0x32, 0x36, 0x35, 0x31, + 0x34, 0x30, 0x33, 0x42, 0x31, 0x34, 0x45, 0x33, 0x33, 0x39, 0x41, 0x42, + 0x45, 0x34, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x33, 0x33, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x45, 0x41, 0x46, 0x38, 0x36, 0x44, + 0x45, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x45, 0x31, + 0x35, 0x34, 0x43, 0x31, 0x32, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x41, 0x38, 0x39, 0x30, 0x42, 0x30, 0x34, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x46, 0x46, 0x46, 0x41, 0x45, + 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x38, + 0x30, 0x45, 0x30, 0x34, 0x33, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x32, 0x42, 0x37, 0x30, 0x39, 0x42, 0x34, 0x39, 0x34, + 0x30, 0x42, 0x45, 0x33, 0x42, 0x31, 0x32, 0x41, 0x32, 0x41, 0x45, 0x34, + 0x34, 0x34, 0x36, 0x34, 0x30, 0x43, 0x35, 0x46, 0x39, 0x46, 0x46, 0x33, + 0x31, 0x36, 0x41, 0x38, 0x34, 0x34, 0x34, 0x34, 0x30, 0x0a, 0x33, 0x34, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x32, 0x43, 0x34, + 0x32, 0x35, 0x45, 0x42, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x41, 0x32, 0x32, 0x45, 0x30, 0x42, 0x45, 0x35, 0x30, 0x34, 0x30, + 0x36, 0x35, 0x37, 0x31, 0x44, 0x38, 0x42, 0x46, 0x41, 0x42, 0x36, 0x43, + 0x35, 0x35, 0x34, 0x30, 0x46, 0x30, 0x38, 0x30, 0x43, 0x32, 0x33, 0x35, + 0x43, 0x38, 0x44, 0x33, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x33, 0x34, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x38, 0x43, 0x32, + 0x33, 0x34, 0x42, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x45, 0x31, 0x43, 0x31, 0x43, 0x42, 0x32, 0x45, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x45, 0x45, 0x39, 0x39, 0x34, 0x33, 0x31, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x44, 0x32, 0x45, + 0x42, 0x36, 0x43, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x38, 0x43, 0x37, 0x39, 0x41, 0x45, 0x33, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x30, 0x44, 0x39, 0x42, 0x36, 0x35, 0x38, 0x32, + 0x45, 0x34, 0x30, 0x0a, 0x33, 0x34, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x43, 0x35, 0x39, 0x32, 0x31, 0x36, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x38, 0x32, 0x35, 0x46, + 0x38, 0x34, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, + 0x36, 0x36, 0x33, 0x31, 0x34, 0x30, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x38, 0x34, 0x36, 0x46, 0x37, 0x46, 0x35, 0x34, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x37, 0x44, 0x42, 0x38, + 0x39, 0x30, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, + 0x31, 0x31, 0x30, 0x34, 0x45, 0x46, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x33, + 0x34, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x43, + 0x33, 0x45, 0x44, 0x45, 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x30, 0x30, 0x46, 0x44, 0x34, 0x45, 0x45, 0x34, 0x46, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x35, 0x39, 0x43, 0x35, + 0x32, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x45, + 0x35, 0x43, 0x44, 0x41, 0x36, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x33, 0x34, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x38, + 0x42, 0x36, 0x34, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x46, 0x41, 0x42, 0x37, 0x44, 0x38, 0x32, 0x42, 0x34, 0x30, + 0x31, 0x33, 0x43, 0x36, 0x31, 0x42, 0x34, 0x45, 0x38, 0x32, 0x33, 0x41, + 0x34, 0x45, 0x34, 0x30, 0x42, 0x39, 0x42, 0x34, 0x31, 0x45, 0x33, 0x44, + 0x37, 0x30, 0x46, 0x32, 0x32, 0x38, 0x34, 0x30, 0x0a, 0x33, 0x34, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x34, 0x35, 0x34, + 0x42, 0x45, 0x43, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x38, 0x34, 0x38, 0x38, 0x44, 0x30, 0x33, 0x46, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x36, 0x38, 0x36, 0x46, 0x44, 0x44, 0x34, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x44, 0x46, + 0x36, 0x35, 0x43, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x45, 0x41, 0x42, 0x39, 0x35, 0x30, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x32, 0x46, 0x32, 0x39, 0x46, 0x34, + 0x34, 0x34, 0x30, 0x45, 0x36, 0x35, 0x35, 0x45, 0x46, 0x38, 0x43, 0x32, + 0x38, 0x36, 0x38, 0x34, 0x33, 0x34, 0x30, 0x42, 0x46, 0x38, 0x39, 0x34, + 0x45, 0x43, 0x43, 0x45, 0x43, 0x36, 0x46, 0x34, 0x43, 0x34, 0x30, 0x0a, + 0x33, 0x34, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x32, 0x46, 0x30, 0x35, 0x44, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x38, 0x33, 0x33, 0x44, 0x37, 0x43, 0x39, 0x33, 0x39, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x32, 0x37, 0x32, 0x39, + 0x37, 0x36, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, + 0x38, 0x37, 0x38, 0x41, 0x45, 0x37, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x42, 0x39, 0x32, 0x37, 0x39, 0x32, 0x33, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x42, 0x34, 0x42, 0x36, + 0x36, 0x30, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x33, 0x34, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x45, 0x35, 0x43, 0x44, 0x44, + 0x32, 0x34, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x32, + 0x34, 0x30, 0x36, 0x45, 0x37, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x38, 0x35, 0x43, 0x33, 0x32, 0x30, 0x39, 0x34, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x43, 0x31, 0x37, 0x33, 0x34, + 0x39, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x41, + 0x37, 0x44, 0x42, 0x36, 0x33, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x38, 0x43, 0x45, 0x39, 0x31, 0x43, 0x33, 0x33, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x43, 0x41, 0x38, 0x34, 0x36, + 0x41, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x42, + 0x33, 0x44, 0x36, 0x30, 0x44, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x43, 0x37, 0x41, 0x35, 0x46, 0x31, 0x46, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x31, 0x43, 0x35, 0x35, + 0x46, 0x31, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, + 0x33, 0x45, 0x34, 0x35, 0x36, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x46, 0x45, 0x39, 0x32, 0x44, 0x45, 0x35, 0x37, 0x34, + 0x30, 0x0a, 0x33, 0x34, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x42, 0x31, 0x32, 0x44, 0x31, 0x38, 0x33, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x39, 0x44, 0x31, 0x31, 0x36, + 0x33, 0x32, 0x34, 0x30, 0x45, 0x43, 0x46, 0x45, 0x41, 0x44, 0x36, 0x30, + 0x39, 0x30, 0x37, 0x38, 0x34, 0x33, 0x34, 0x30, 0x41, 0x36, 0x34, 0x33, + 0x35, 0x46, 0x42, 0x39, 0x45, 0x31, 0x31, 0x34, 0x33, 0x42, 0x34, 0x30, + 0x0a, 0x33, 0x34, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x38, 0x35, 0x36, 0x43, 0x42, 0x30, 0x33, 0x34, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x34, 0x35, 0x34, 0x35, 0x39, 0x43, 0x41, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x42, 0x43, 0x45, + 0x30, 0x36, 0x45, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x30, 0x45, 0x30, 0x43, 0x39, 0x42, 0x34, 0x31, 0x45, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x43, 0x44, 0x42, 0x38, 0x37, 0x42, 0x34, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x33, 0x43, + 0x46, 0x39, 0x42, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x46, 0x44, 0x30, 0x43, 0x32, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x32, 0x33, 0x41, 0x43, 0x41, 0x36, 0x46, 0x35, + 0x33, 0x34, 0x30, 0x0a, 0x33, 0x35, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x45, 0x34, 0x34, 0x38, 0x34, 0x35, 0x35, 0x34, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x41, 0x32, 0x41, 0x43, + 0x42, 0x35, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x43, 0x35, 0x45, 0x45, 0x31, 0x44, 0x32, 0x43, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x41, 0x33, 0x34, 0x34, 0x35, 0x43, 0x42, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x45, 0x31, 0x37, 0x39, 0x41, + 0x43, 0x44, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x42, 0x42, 0x38, 0x36, 0x31, 0x32, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x34, 0x30, 0x31, 0x46, 0x46, 0x32, 0x31, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x39, 0x36, + 0x34, 0x45, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x37, 0x37, 0x31, 0x34, 0x41, 0x30, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x41, 0x31, 0x43, 0x33, 0x31, 0x42, 0x34, 0x44, + 0x34, 0x30, 0x0a, 0x33, 0x35, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x34, 0x32, 0x32, 0x35, 0x31, 0x37, 0x37, 0x34, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x38, 0x31, 0x43, 0x31, 0x35, + 0x35, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x37, + 0x44, 0x43, 0x33, 0x39, 0x44, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x34, 0x36, 0x34, 0x41, 0x34, 0x42, 0x30, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x45, 0x43, 0x41, 0x43, 0x32, + 0x42, 0x32, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x35, + 0x44, 0x38, 0x46, 0x46, 0x33, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x33, 0x35, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, 0x31, + 0x43, 0x35, 0x44, 0x32, 0x31, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x44, 0x43, 0x36, 0x42, 0x32, 0x33, 0x39, 0x37, 0x35, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x42, 0x44, 0x33, + 0x42, 0x30, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x39, 0x31, + 0x35, 0x30, 0x35, 0x31, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x30, 0x32, 0x44, 0x31, 0x32, 0x33, 0x32, 0x34, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x33, 0x33, 0x38, 0x45, 0x43, 0x45, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x31, 0x33, + 0x32, 0x34, 0x35, 0x45, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x34, 0x36, 0x39, 0x41, 0x42, 0x30, 0x38, 0x34, 0x42, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x44, 0x35, 0x31, 0x38, + 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x42, 0x44, + 0x30, 0x42, 0x32, 0x43, 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x33, 0x34, 0x35, 0x43, 0x39, 0x34, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x41, 0x34, 0x41, 0x36, 0x45, 0x31, + 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x34, 0x44, + 0x36, 0x31, 0x45, 0x46, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x34, 0x31, 0x38, 0x41, 0x35, 0x44, 0x39, 0x35, 0x33, 0x34, 0x30, + 0x0a, 0x33, 0x35, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x32, 0x36, 0x31, 0x46, 0x37, 0x33, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x45, 0x34, 0x43, 0x45, 0x41, 0x41, 0x34, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x32, 0x32, + 0x34, 0x30, 0x34, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x43, 0x46, 0x44, 0x36, 0x46, 0x44, 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x34, 0x41, 0x37, 0x44, 0x37, 0x33, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x38, 0x35, + 0x34, 0x41, 0x38, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x33, 0x35, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x32, 0x39, 0x44, 0x43, 0x42, + 0x43, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, + 0x43, 0x34, 0x41, 0x41, 0x34, 0x45, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x42, 0x30, 0x35, 0x41, 0x33, 0x42, 0x46, 0x32, 0x34, 0x43, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x33, 0x46, 0x31, 0x41, + 0x33, 0x33, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, + 0x38, 0x34, 0x44, 0x43, 0x44, 0x38, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x45, 0x46, 0x46, 0x42, 0x32, 0x44, 0x30, 0x41, + 0x34, 0x30, 0x0a, 0x33, 0x35, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x44, 0x30, 0x46, 0x45, 0x45, 0x46, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x31, 0x45, 0x30, 0x32, 0x36, + 0x43, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x30, + 0x45, 0x32, 0x46, 0x42, 0x43, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x41, 0x33, 0x42, 0x32, 0x32, 0x38, 0x37, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x46, 0x44, 0x33, 0x36, 0x37, + 0x30, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, + 0x32, 0x37, 0x35, 0x34, 0x44, 0x31, 0x36, 0x34, 0x30, 0x42, 0x41, 0x41, + 0x37, 0x38, 0x33, 0x42, 0x37, 0x38, 0x38, 0x36, 0x36, 0x35, 0x30, 0x34, + 0x30, 0x43, 0x36, 0x39, 0x41, 0x34, 0x33, 0x39, 0x32, 0x30, 0x33, 0x39, + 0x30, 0x32, 0x45, 0x34, 0x30, 0x0a, 0x33, 0x35, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, 0x38, 0x30, 0x34, 0x32, 0x35, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, + 0x39, 0x45, 0x37, 0x34, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x30, 0x46, 0x45, 0x31, 0x44, 0x34, 0x46, 0x32, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x38, 0x32, 0x42, 0x32, 0x44, 0x44, + 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x31, + 0x41, 0x37, 0x46, 0x35, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x30, 0x44, 0x41, 0x33, 0x42, 0x46, 0x35, 0x31, 0x33, 0x34, 0x30, + 0x0a, 0x33, 0x35, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x30, 0x38, 0x43, 0x46, 0x44, 0x43, 0x45, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x36, 0x32, 0x33, 0x46, 0x33, 0x33, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x32, 0x46, 0x38, + 0x38, 0x43, 0x34, 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x38, 0x44, 0x45, 0x41, 0x35, 0x45, 0x43, 0x34, 0x35, 0x34, 0x30, 0x36, + 0x33, 0x45, 0x42, 0x31, 0x45, 0x42, 0x34, 0x43, 0x32, 0x31, 0x32, 0x34, + 0x39, 0x34, 0x30, 0x36, 0x45, 0x38, 0x36, 0x44, 0x30, 0x42, 0x41, 0x42, + 0x42, 0x45, 0x39, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x33, 0x35, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, 0x41, 0x38, 0x33, + 0x39, 0x37, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, + 0x37, 0x32, 0x41, 0x43, 0x38, 0x45, 0x33, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x43, 0x30, 0x35, 0x31, 0x46, 0x34, 0x37, 0x34, 0x32, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x33, 0x37, 0x45, 0x31, + 0x32, 0x41, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, + 0x44, 0x46, 0x41, 0x43, 0x30, 0x37, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x33, 0x42, 0x34, 0x42, 0x32, 0x35, 0x31, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x35, 0x33, 0x33, 0x31, + 0x30, 0x45, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, + 0x44, 0x45, 0x35, 0x44, 0x41, 0x31, 0x33, 0x30, 0x34, 0x30, 0x45, 0x39, + 0x37, 0x39, 0x31, 0x41, 0x39, 0x41, 0x36, 0x34, 0x35, 0x32, 0x34, 0x31, + 0x34, 0x30, 0x43, 0x34, 0x35, 0x36, 0x46, 0x35, 0x34, 0x42, 0x42, 0x33, + 0x36, 0x33, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x33, 0x35, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x33, 0x41, 0x39, 0x31, 0x42, + 0x43, 0x33, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x35, + 0x31, 0x34, 0x37, 0x35, 0x36, 0x34, 0x45, 0x34, 0x30, 0x42, 0x35, 0x34, + 0x34, 0x46, 0x45, 0x35, 0x32, 0x41, 0x46, 0x37, 0x44, 0x33, 0x43, 0x34, + 0x30, 0x44, 0x38, 0x44, 0x37, 0x46, 0x44, 0x31, 0x39, 0x38, 0x30, 0x42, + 0x44, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x33, 0x36, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x36, 0x44, 0x46, 0x41, 0x46, 0x42, + 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x33, 0x39, + 0x44, 0x45, 0x37, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x35, 0x38, 0x44, 0x36, 0x44, 0x42, 0x33, 0x46, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x32, 0x44, 0x44, 0x45, 0x32, 0x33, + 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x33, 0x39, + 0x31, 0x41, 0x39, 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x43, 0x42, 0x36, 0x43, 0x42, 0x37, 0x45, 0x34, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x37, 0x42, 0x39, 0x36, 0x41, 0x45, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x34, 0x36, + 0x38, 0x35, 0x46, 0x46, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x38, 0x31, 0x45, 0x37, 0x35, 0x34, 0x33, 0x34, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x34, 0x41, 0x35, 0x45, 0x36, 0x42, + 0x34, 0x33, 0x34, 0x30, 0x0a, 0x33, 0x36, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x43, 0x31, 0x42, 0x37, 0x45, 0x39, 0x45, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x33, 0x36, 0x35, + 0x36, 0x38, 0x38, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x30, 0x41, 0x35, 0x45, 0x36, 0x34, 0x42, 0x32, 0x44, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x41, 0x32, 0x43, 0x32, 0x38, 0x43, 0x34, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x44, + 0x37, 0x39, 0x32, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x38, 0x42, 0x39, 0x36, 0x37, 0x33, 0x41, 0x34, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x38, 0x34, 0x42, 0x38, 0x31, 0x43, 0x44, 0x33, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x46, 0x38, 0x38, + 0x46, 0x33, 0x38, 0x35, 0x35, 0x34, 0x30, 0x0a, 0x33, 0x36, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x30, 0x38, 0x42, 0x30, + 0x37, 0x35, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x31, 0x36, 0x32, 0x30, 0x39, 0x43, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x38, 0x37, 0x34, 0x34, 0x36, 0x38, 0x33, 0x33, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x46, 0x33, 0x41, 0x39, + 0x42, 0x33, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x45, 0x42, 0x34, 0x38, 0x39, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x34, 0x37, 0x46, 0x44, 0x42, 0x35, 0x34, 0x34, 0x41, + 0x34, 0x30, 0x0a, 0x33, 0x36, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x36, 0x33, 0x43, 0x31, 0x43, 0x44, 0x33, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x43, 0x37, 0x32, 0x37, + 0x44, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x34, + 0x43, 0x36, 0x46, 0x43, 0x33, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x36, 0x32, 0x43, 0x45, 0x45, 0x31, 0x42, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x33, 0x44, 0x39, 0x46, + 0x32, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, 0x43, + 0x32, 0x32, 0x36, 0x31, 0x41, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x45, 0x38, 0x34, 0x43, 0x34, 0x33, 0x37, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x37, 0x32, 0x39, 0x34, 0x45, + 0x30, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x46, + 0x37, 0x38, 0x31, 0x36, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x30, 0x33, 0x41, 0x36, 0x37, 0x32, 0x31, 0x37, 0x34, + 0x30, 0x0a, 0x33, 0x36, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x38, 0x34, 0x39, 0x36, 0x33, 0x41, 0x43, 0x34, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x45, 0x43, 0x39, 0x33, 0x31, + 0x34, 0x38, 0x34, 0x30, 0x43, 0x38, 0x32, 0x32, 0x39, 0x39, 0x39, 0x37, + 0x39, 0x43, 0x46, 0x37, 0x34, 0x38, 0x34, 0x30, 0x42, 0x30, 0x46, 0x31, + 0x42, 0x43, 0x44, 0x33, 0x30, 0x39, 0x33, 0x38, 0x34, 0x46, 0x34, 0x30, + 0x0a, 0x33, 0x36, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x30, 0x36, 0x43, 0x33, 0x38, 0x38, 0x41, 0x30, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x42, 0x34, 0x38, 0x32, 0x37, 0x31, 0x34, + 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x32, 0x37, 0x35, + 0x46, 0x35, 0x39, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x33, 0x38, 0x38, 0x34, 0x36, 0x46, 0x34, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x30, 0x34, 0x31, 0x44, 0x33, 0x42, 0x42, 0x32, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x36, 0x41, 0x42, + 0x36, 0x44, 0x38, 0x32, 0x31, 0x34, 0x30, 0x0a, 0x33, 0x36, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x35, 0x39, 0x36, 0x31, + 0x36, 0x38, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, + 0x39, 0x30, 0x33, 0x44, 0x35, 0x35, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x38, 0x43, 0x44, 0x37, 0x34, 0x38, 0x42, 0x35, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x37, 0x44, 0x31, 0x34, + 0x35, 0x33, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x33, 0x36, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x32, 0x44, 0x39, 0x46, 0x30, + 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x36, + 0x37, 0x38, 0x30, 0x31, 0x46, 0x32, 0x35, 0x34, 0x30, 0x45, 0x44, 0x37, + 0x30, 0x36, 0x44, 0x37, 0x44, 0x37, 0x34, 0x39, 0x42, 0x34, 0x30, 0x34, + 0x30, 0x42, 0x32, 0x46, 0x38, 0x31, 0x37, 0x34, 0x33, 0x35, 0x33, 0x36, + 0x30, 0x33, 0x34, 0x34, 0x30, 0x0a, 0x33, 0x36, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x43, 0x42, 0x30, 0x37, 0x37, 0x41, + 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x30, 0x39, + 0x39, 0x41, 0x42, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x38, 0x33, 0x46, 0x42, 0x39, 0x38, 0x43, 0x35, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x34, 0x32, 0x37, 0x30, 0x35, + 0x33, 0x46, 0x34, 0x30, 0x36, 0x36, 0x31, 0x44, 0x33, 0x32, 0x35, 0x38, + 0x32, 0x30, 0x36, 0x30, 0x34, 0x44, 0x34, 0x30, 0x32, 0x46, 0x35, 0x32, + 0x33, 0x39, 0x31, 0x33, 0x45, 0x46, 0x39, 0x38, 0x35, 0x30, 0x34, 0x30, + 0x0a, 0x33, 0x36, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x38, 0x38, 0x44, 0x30, 0x35, 0x42, 0x39, 0x34, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x43, 0x35, 0x42, 0x41, 0x34, 0x43, 0x34, 0x34, + 0x46, 0x34, 0x30, 0x35, 0x31, 0x35, 0x31, 0x44, 0x43, 0x45, 0x45, 0x41, + 0x41, 0x44, 0x45, 0x34, 0x31, 0x34, 0x30, 0x31, 0x46, 0x46, 0x45, 0x33, + 0x37, 0x42, 0x37, 0x34, 0x34, 0x31, 0x45, 0x34, 0x44, 0x34, 0x30, 0x0a, + 0x33, 0x37, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x43, 0x37, 0x38, 0x43, 0x46, 0x37, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x30, 0x32, 0x43, 0x37, 0x33, 0x44, 0x31, 0x33, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x41, 0x36, 0x31, 0x37, + 0x30, 0x46, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x32, + 0x37, 0x31, 0x39, 0x43, 0x30, 0x41, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x33, 0x38, 0x34, 0x44, 0x36, 0x42, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x37, 0x32, 0x41, 0x43, + 0x46, 0x30, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x33, 0x37, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x33, 0x30, 0x34, 0x32, 0x46, + 0x42, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x36, + 0x42, 0x38, 0x45, 0x31, 0x32, 0x35, 0x37, 0x34, 0x30, 0x41, 0x34, 0x45, + 0x31, 0x32, 0x45, 0x31, 0x30, 0x35, 0x46, 0x44, 0x36, 0x35, 0x33, 0x34, + 0x30, 0x45, 0x43, 0x33, 0x36, 0x39, 0x37, 0x46, 0x41, 0x34, 0x41, 0x30, + 0x33, 0x35, 0x34, 0x34, 0x30, 0x0a, 0x33, 0x37, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x45, 0x34, 0x41, 0x46, 0x34, 0x42, 0x31, + 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x41, 0x35, + 0x35, 0x34, 0x34, 0x44, 0x34, 0x36, 0x34, 0x30, 0x43, 0x43, 0x42, 0x39, + 0x43, 0x44, 0x44, 0x44, 0x33, 0x31, 0x44, 0x33, 0x34, 0x36, 0x34, 0x30, + 0x42, 0x30, 0x38, 0x32, 0x35, 0x38, 0x42, 0x38, 0x30, 0x39, 0x39, 0x46, + 0x33, 0x34, 0x34, 0x30, 0x0a, 0x33, 0x37, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x43, 0x32, 0x42, 0x45, 0x42, 0x45, 0x39, 0x34, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x46, 0x42, 0x44, + 0x34, 0x35, 0x30, 0x32, 0x30, 0x34, 0x30, 0x34, 0x42, 0x43, 0x34, 0x30, + 0x45, 0x34, 0x42, 0x42, 0x31, 0x34, 0x31, 0x34, 0x31, 0x34, 0x30, 0x42, + 0x36, 0x32, 0x45, 0x41, 0x41, 0x36, 0x44, 0x43, 0x41, 0x44, 0x30, 0x33, + 0x41, 0x34, 0x30, 0x0a, 0x33, 0x37, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x32, 0x38, 0x45, 0x46, 0x44, 0x44, 0x33, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x41, 0x30, 0x42, 0x44, + 0x35, 0x33, 0x33, 0x30, 0x34, 0x30, 0x32, 0x39, 0x35, 0x34, 0x41, 0x41, + 0x37, 0x32, 0x43, 0x45, 0x36, 0x44, 0x33, 0x39, 0x34, 0x30, 0x36, 0x38, + 0x37, 0x41, 0x37, 0x37, 0x37, 0x37, 0x44, 0x31, 0x33, 0x44, 0x33, 0x35, + 0x34, 0x30, 0x0a, 0x33, 0x37, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x45, 0x37, 0x30, 0x33, 0x44, 0x45, 0x33, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, 0x30, 0x39, 0x43, 0x39, 0x37, + 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x45, + 0x32, 0x44, 0x32, 0x46, 0x32, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x31, 0x42, 0x37, 0x31, 0x45, 0x32, 0x34, 0x43, 0x34, + 0x30, 0x31, 0x30, 0x44, 0x32, 0x31, 0x46, 0x33, 0x39, 0x39, 0x32, 0x34, + 0x35, 0x34, 0x42, 0x34, 0x30, 0x33, 0x30, 0x42, 0x38, 0x38, 0x36, 0x43, + 0x36, 0x32, 0x38, 0x32, 0x30, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x33, 0x37, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x36, 0x34, + 0x36, 0x39, 0x42, 0x43, 0x32, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x43, 0x30, 0x38, 0x42, 0x46, 0x32, 0x37, 0x34, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x35, 0x34, 0x41, 0x30, 0x34, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x44, 0x31, + 0x32, 0x36, 0x46, 0x46, 0x34, 0x36, 0x34, 0x30, 0x33, 0x37, 0x36, 0x36, + 0x43, 0x35, 0x44, 0x33, 0x38, 0x33, 0x35, 0x42, 0x34, 0x43, 0x34, 0x30, + 0x37, 0x31, 0x31, 0x42, 0x42, 0x32, 0x34, 0x42, 0x30, 0x32, 0x32, 0x38, + 0x34, 0x43, 0x34, 0x30, 0x0a, 0x33, 0x37, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x38, 0x33, 0x37, 0x38, 0x46, 0x33, 0x30, 0x33, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x35, 0x32, 0x30, + 0x37, 0x37, 0x35, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x34, 0x43, 0x32, 0x46, 0x44, 0x41, 0x33, 0x34, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x44, 0x42, 0x31, 0x31, 0x31, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x36, 0x32, 0x37, + 0x41, 0x30, 0x45, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x32, 0x44, 0x45, 0x39, 0x38, 0x45, 0x31, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x35, 0x43, 0x31, 0x44, 0x45, 0x30, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x36, 0x39, 0x33, + 0x37, 0x41, 0x35, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x38, 0x31, 0x42, 0x32, 0x33, 0x46, 0x30, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x41, 0x46, 0x37, 0x39, 0x34, 0x39, 0x37, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x39, 0x33, 0x45, + 0x35, 0x41, 0x39, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x42, 0x39, 0x37, 0x32, 0x34, 0x33, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x39, 0x41, 0x36, 0x42, 0x32, 0x33, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x38, 0x33, 0x31, + 0x33, 0x37, 0x38, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x33, 0x37, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x30, 0x45, 0x34, 0x34, + 0x35, 0x44, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, + 0x35, 0x31, 0x33, 0x32, 0x34, 0x43, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x36, 0x33, 0x32, 0x46, 0x33, 0x46, 0x34, 0x46, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x42, 0x31, 0x31, 0x33, + 0x34, 0x44, 0x31, 0x46, 0x34, 0x30, 0x0a, 0x33, 0x37, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x33, 0x45, 0x37, 0x30, + 0x44, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x34, + 0x38, 0x43, 0x39, 0x45, 0x38, 0x34, 0x41, 0x34, 0x30, 0x39, 0x46, 0x43, + 0x35, 0x39, 0x44, 0x30, 0x41, 0x30, 0x37, 0x38, 0x32, 0x34, 0x30, 0x34, + 0x30, 0x35, 0x42, 0x39, 0x36, 0x43, 0x44, 0x33, 0x45, 0x41, 0x39, 0x41, + 0x45, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x33, 0x38, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x41, 0x37, 0x32, 0x45, 0x33, 0x45, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x46, 0x43, + 0x37, 0x36, 0x43, 0x34, 0x34, 0x46, 0x34, 0x30, 0x34, 0x39, 0x31, 0x44, + 0x31, 0x42, 0x38, 0x35, 0x46, 0x46, 0x36, 0x33, 0x34, 0x41, 0x34, 0x30, + 0x41, 0x43, 0x41, 0x41, 0x39, 0x41, 0x44, 0x43, 0x39, 0x30, 0x41, 0x43, + 0x33, 0x38, 0x34, 0x30, 0x0a, 0x33, 0x38, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x37, 0x34, 0x45, 0x33, 0x44, 0x33, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x34, 0x41, 0x37, 0x41, + 0x38, 0x32, 0x43, 0x34, 0x31, 0x34, 0x30, 0x33, 0x38, 0x33, 0x35, 0x38, + 0x38, 0x42, 0x45, 0x45, 0x30, 0x35, 0x43, 0x35, 0x33, 0x34, 0x30, 0x36, + 0x33, 0x44, 0x36, 0x30, 0x39, 0x42, 0x44, 0x33, 0x32, 0x39, 0x38, 0x34, + 0x44, 0x34, 0x30, 0x0a, 0x33, 0x38, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x32, 0x36, 0x39, 0x32, 0x35, 0x41, 0x36, 0x35, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x32, 0x38, 0x41, 0x36, + 0x30, 0x43, 0x33, 0x42, 0x34, 0x30, 0x36, 0x30, 0x42, 0x41, 0x34, 0x31, + 0x35, 0x41, 0x45, 0x44, 0x42, 0x37, 0x35, 0x32, 0x34, 0x30, 0x34, 0x39, + 0x31, 0x33, 0x36, 0x44, 0x33, 0x38, 0x30, 0x35, 0x36, 0x30, 0x34, 0x32, + 0x34, 0x30, 0x0a, 0x33, 0x38, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x38, 0x46, 0x35, 0x35, 0x31, 0x30, 0x44, 0x34, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x44, 0x44, 0x38, 0x42, + 0x43, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, 0x31, + 0x42, 0x45, 0x33, 0x34, 0x43, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x38, 0x45, 0x45, 0x34, 0x32, 0x34, 0x37, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x32, 0x31, 0x38, + 0x39, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x35, 0x41, 0x32, 0x35, 0x45, 0x46, 0x30, 0x33, 0x46, 0x0a, 0x33, 0x38, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x39, 0x39, + 0x45, 0x34, 0x44, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x43, 0x42, 0x45, 0x39, 0x44, 0x41, 0x46, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x46, 0x31, 0x37, 0x44, 0x32, 0x36, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, 0x36, 0x37, + 0x31, 0x37, 0x43, 0x35, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x33, 0x38, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x32, 0x33, 0x31, + 0x43, 0x38, 0x41, 0x31, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x34, 0x34, 0x46, 0x31, 0x38, 0x38, 0x42, 0x34, 0x37, 0x34, 0x30, 0x35, + 0x35, 0x35, 0x37, 0x46, 0x41, 0x38, 0x39, 0x38, 0x43, 0x42, 0x39, 0x33, + 0x34, 0x34, 0x30, 0x35, 0x37, 0x44, 0x44, 0x31, 0x43, 0x31, 0x38, 0x41, + 0x30, 0x31, 0x32, 0x34, 0x45, 0x34, 0x30, 0x0a, 0x33, 0x38, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x46, 0x46, 0x41, 0x42, + 0x33, 0x36, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x45, + 0x33, 0x42, 0x36, 0x35, 0x42, 0x43, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x45, 0x45, 0x34, 0x45, 0x41, 0x45, 0x42, 0x35, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x41, 0x39, + 0x33, 0x45, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x33, 0x38, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x45, 0x34, 0x32, 0x43, 0x45, 0x45, + 0x33, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x34, + 0x31, 0x34, 0x38, 0x31, 0x35, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x44, 0x38, 0x33, 0x44, 0x41, 0x45, 0x33, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x35, 0x45, 0x42, 0x31, 0x33, + 0x30, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x33, 0x38, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x45, 0x32, 0x30, 0x33, 0x30, + 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x45, 0x39, + 0x32, 0x42, 0x37, 0x32, 0x35, 0x32, 0x34, 0x30, 0x44, 0x36, 0x30, 0x44, + 0x42, 0x33, 0x36, 0x30, 0x31, 0x31, 0x32, 0x45, 0x34, 0x45, 0x34, 0x30, + 0x30, 0x46, 0x36, 0x42, 0x32, 0x38, 0x35, 0x45, 0x35, 0x46, 0x30, 0x33, + 0x35, 0x32, 0x34, 0x30, 0x0a, 0x33, 0x38, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x37, 0x45, 0x39, 0x39, 0x30, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x43, 0x44, 0x42, 0x45, + 0x42, 0x32, 0x39, 0x34, 0x31, 0x34, 0x30, 0x37, 0x38, 0x35, 0x35, 0x44, + 0x46, 0x44, 0x33, 0x37, 0x33, 0x35, 0x31, 0x33, 0x36, 0x34, 0x30, 0x35, + 0x39, 0x45, 0x35, 0x38, 0x37, 0x35, 0x36, 0x39, 0x33, 0x44, 0x34, 0x34, + 0x46, 0x34, 0x30, 0x0a, 0x33, 0x39, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x37, 0x31, 0x30, 0x46, 0x31, 0x39, 0x34, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x34, 0x37, 0x44, 0x30, + 0x45, 0x42, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x46, 0x43, 0x32, 0x30, 0x45, 0x32, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x38, 0x31, 0x33, 0x44, 0x35, 0x43, 0x39, 0x34, 0x41, + 0x34, 0x30, 0x39, 0x42, 0x37, 0x39, 0x34, 0x34, 0x30, 0x41, 0x39, 0x32, + 0x30, 0x46, 0x34, 0x30, 0x34, 0x30, 0x34, 0x38, 0x33, 0x32, 0x30, 0x35, + 0x30, 0x39, 0x38, 0x41, 0x37, 0x33, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x33, + 0x39, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x37, + 0x44, 0x42, 0x43, 0x42, 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x37, 0x36, 0x42, 0x38, 0x34, 0x45, 0x42, 0x33, + 0x46, 0x39, 0x44, 0x35, 0x30, 0x35, 0x38, 0x33, 0x31, 0x37, 0x38, 0x32, + 0x32, 0x35, 0x31, 0x34, 0x30, 0x38, 0x30, 0x33, 0x37, 0x39, 0x33, 0x42, + 0x35, 0x42, 0x37, 0x43, 0x31, 0x33, 0x46, 0x34, 0x30, 0x0a, 0x33, 0x39, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x35, 0x37, + 0x36, 0x33, 0x30, 0x36, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x46, 0x38, 0x46, 0x36, 0x39, 0x43, 0x34, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x43, 0x46, 0x31, 0x46, 0x31, 0x38, + 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x32, 0x36, 0x31, + 0x44, 0x38, 0x38, 0x36, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x41, 0x41, 0x31, 0x30, 0x32, 0x41, 0x30, 0x35, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x41, 0x37, 0x41, 0x38, 0x39, + 0x31, 0x31, 0x34, 0x30, 0x0a, 0x33, 0x39, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x41, 0x46, 0x39, 0x44, 0x41, 0x45, 0x31, 0x35, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x35, 0x34, 0x30, + 0x34, 0x46, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x38, 0x41, 0x37, 0x32, 0x42, 0x31, 0x35, 0x34, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x34, 0x45, 0x39, 0x38, 0x38, 0x32, 0x32, + 0x31, 0x34, 0x30, 0x33, 0x43, 0x33, 0x35, 0x39, 0x36, 0x45, 0x43, 0x30, + 0x37, 0x30, 0x42, 0x34, 0x44, 0x34, 0x30, 0x46, 0x43, 0x42, 0x41, 0x37, + 0x41, 0x45, 0x42, 0x41, 0x32, 0x30, 0x32, 0x33, 0x35, 0x34, 0x30, 0x0a, + 0x33, 0x39, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, + 0x37, 0x45, 0x43, 0x35, 0x41, 0x42, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x45, 0x37, 0x36, 0x37, 0x44, 0x43, 0x33, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x36, 0x46, 0x41, 0x38, 0x33, + 0x37, 0x38, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, + 0x42, 0x44, 0x41, 0x33, 0x33, 0x39, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x38, 0x36, 0x45, 0x43, 0x36, 0x43, 0x43, 0x34, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x45, 0x39, 0x41, + 0x34, 0x33, 0x30, 0x46, 0x34, 0x30, 0x43, 0x45, 0x36, 0x36, 0x33, 0x32, + 0x43, 0x39, 0x39, 0x46, 0x43, 0x32, 0x35, 0x32, 0x34, 0x30, 0x33, 0x36, + 0x30, 0x46, 0x42, 0x46, 0x41, 0x31, 0x33, 0x31, 0x37, 0x35, 0x34, 0x46, + 0x34, 0x30, 0x0a, 0x33, 0x39, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x34, 0x34, 0x36, 0x30, 0x41, 0x37, 0x31, 0x34, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x32, 0x36, 0x30, 0x30, + 0x38, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x46, + 0x31, 0x37, 0x37, 0x30, 0x34, 0x30, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x36, 0x36, 0x41, 0x38, 0x30, 0x31, 0x42, 0x35, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x31, 0x41, 0x30, 0x32, 0x33, + 0x38, 0x32, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x45, + 0x41, 0x33, 0x32, 0x43, 0x37, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x38, 0x42, 0x34, 0x30, 0x42, 0x33, 0x42, 0x33, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x32, 0x36, 0x35, 0x30, 0x34, + 0x43, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x45, + 0x31, 0x31, 0x42, 0x37, 0x36, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x30, 0x32, 0x39, 0x38, 0x30, 0x32, 0x41, 0x34, 0x35, 0x34, + 0x30, 0x0a, 0x33, 0x39, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x36, 0x30, 0x33, 0x36, 0x32, 0x35, 0x46, 0x35, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x35, 0x45, 0x39, 0x34, 0x37, 0x30, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x39, 0x46, + 0x42, 0x43, 0x39, 0x43, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x44, 0x38, 0x38, 0x35, 0x38, 0x39, 0x36, 0x41, 0x34, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x36, 0x33, 0x42, 0x39, 0x39, 0x45, + 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x32, 0x45, + 0x33, 0x32, 0x46, 0x42, 0x31, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x31, 0x42, 0x36, 0x41, 0x32, 0x31, 0x31, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x32, 0x30, 0x32, 0x33, 0x31, 0x43, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x46, + 0x37, 0x46, 0x43, 0x45, 0x32, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x41, 0x46, 0x45, 0x42, 0x31, 0x45, 0x45, 0x33, 0x46, + 0x0a, 0x33, 0x39, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x33, 0x34, 0x32, 0x39, 0x44, 0x36, 0x32, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x43, 0x46, 0x39, 0x42, 0x33, 0x43, 0x38, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x44, 0x46, 0x31, + 0x45, 0x31, 0x37, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x32, 0x38, 0x33, 0x30, 0x45, 0x36, 0x31, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x30, 0x45, 0x46, 0x44, 0x45, 0x33, 0x35, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x35, + 0x41, 0x31, 0x43, 0x44, 0x34, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x43, 0x36, 0x34, 0x32, 0x44, 0x39, 0x39, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x34, 0x45, 0x30, 0x42, 0x39, 0x41, 0x36, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x37, 0x37, 0x41, + 0x36, 0x32, 0x46, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x30, 0x44, 0x35, 0x31, 0x42, 0x38, 0x35, 0x35, 0x36, 0x34, 0x30, 0x0a, + 0x33, 0x39, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, + 0x46, 0x36, 0x45, 0x44, 0x44, 0x46, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x36, 0x33, 0x46, 0x39, 0x43, 0x41, 0x30, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x44, 0x37, 0x43, + 0x30, 0x35, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x38, 0x35, 0x38, 0x33, 0x39, 0x43, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x41, 0x41, 0x45, 0x35, 0x45, 0x42, 0x30, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x32, 0x39, 0x45, 0x36, + 0x41, 0x38, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x33, 0x39, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x38, 0x34, 0x33, 0x45, 0x30, + 0x39, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x34, + 0x38, 0x37, 0x44, 0x42, 0x46, 0x32, 0x34, 0x34, 0x30, 0x35, 0x30, 0x33, + 0x44, 0x38, 0x44, 0x36, 0x30, 0x32, 0x38, 0x32, 0x34, 0x34, 0x39, 0x34, + 0x30, 0x35, 0x36, 0x41, 0x42, 0x45, 0x43, 0x44, 0x46, 0x34, 0x45, 0x32, + 0x42, 0x34, 0x30, 0x34, 0x30, 0x0a, 0x34, 0x30, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x41, 0x39, 0x30, 0x37, 0x42, 0x37, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x32, 0x32, + 0x39, 0x34, 0x43, 0x33, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x38, 0x35, 0x45, 0x41, 0x35, 0x36, 0x32, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x30, 0x34, 0x32, 0x34, 0x43, 0x42, + 0x35, 0x38, 0x34, 0x30, 0x42, 0x38, 0x34, 0x41, 0x37, 0x33, 0x37, 0x44, + 0x36, 0x41, 0x42, 0x33, 0x34, 0x37, 0x34, 0x30, 0x45, 0x37, 0x36, 0x37, + 0x44, 0x43, 0x42, 0x42, 0x42, 0x30, 0x33, 0x33, 0x35, 0x35, 0x34, 0x30, + 0x0a, 0x34, 0x30, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x32, 0x46, 0x36, 0x31, 0x46, 0x44, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x45, 0x30, 0x30, 0x43, 0x38, 0x38, 0x35, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x37, 0x31, 0x32, + 0x41, 0x34, 0x35, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x43, 0x35, 0x35, 0x35, 0x32, 0x34, 0x44, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x30, 0x31, 0x45, 0x46, 0x34, 0x31, 0x38, 0x32, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x43, 0x43, 0x32, + 0x45, 0x46, 0x34, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x34, 0x30, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x41, 0x31, 0x35, 0x42, + 0x34, 0x30, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x45, 0x38, 0x33, 0x36, 0x36, 0x32, 0x35, 0x38, 0x34, 0x30, 0x45, 0x38, + 0x36, 0x37, 0x42, 0x36, 0x42, 0x30, 0x33, 0x41, 0x32, 0x42, 0x34, 0x32, + 0x34, 0x30, 0x35, 0x31, 0x42, 0x44, 0x46, 0x41, 0x39, 0x46, 0x45, 0x36, + 0x31, 0x39, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x34, 0x30, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x37, 0x30, 0x35, 0x44, 0x35, + 0x41, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, 0x32, + 0x43, 0x46, 0x32, 0x33, 0x37, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x38, 0x33, 0x41, 0x30, 0x36, 0x36, 0x41, 0x33, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x42, 0x41, 0x30, 0x46, + 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x38, + 0x35, 0x35, 0x30, 0x41, 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x41, 0x33, 0x30, 0x39, 0x34, 0x30, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x36, 0x43, 0x36, 0x38, 0x37, + 0x42, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x45, + 0x43, 0x46, 0x35, 0x44, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x43, 0x44, 0x42, 0x46, 0x33, 0x33, 0x39, 0x35, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, 0x46, 0x30, 0x38, 0x36, 0x44, + 0x45, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x34, 0x30, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x39, 0x34, 0x33, 0x30, 0x46, + 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x34, + 0x39, 0x33, 0x33, 0x34, 0x32, 0x32, 0x34, 0x30, 0x38, 0x32, 0x42, 0x44, + 0x38, 0x36, 0x37, 0x34, 0x35, 0x37, 0x39, 0x44, 0x34, 0x44, 0x34, 0x30, + 0x36, 0x41, 0x44, 0x32, 0x46, 0x34, 0x34, 0x35, 0x39, 0x37, 0x38, 0x37, + 0x32, 0x46, 0x34, 0x30, 0x0a, 0x34, 0x30, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x30, 0x42, 0x36, 0x33, 0x36, 0x35, 0x31, 0x30, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x43, 0x42, 0x46, + 0x36, 0x42, 0x39, 0x35, 0x35, 0x34, 0x30, 0x37, 0x34, 0x39, 0x41, 0x41, + 0x44, 0x42, 0x45, 0x31, 0x35, 0x39, 0x41, 0x32, 0x46, 0x34, 0x30, 0x38, + 0x33, 0x39, 0x44, 0x37, 0x46, 0x41, 0x36, 0x43, 0x31, 0x32, 0x46, 0x33, + 0x43, 0x34, 0x30, 0x0a, 0x34, 0x30, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x42, 0x46, 0x34, 0x38, 0x44, 0x37, 0x32, 0x45, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x30, + 0x36, 0x30, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x41, + 0x38, 0x42, 0x33, 0x38, 0x42, 0x42, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x41, 0x38, 0x31, 0x32, 0x43, 0x45, 0x41, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x38, 0x36, 0x33, + 0x41, 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x44, 0x45, 0x36, 0x34, 0x30, 0x30, 0x33, 0x34, 0x34, 0x30, 0x44, 0x38, + 0x33, 0x33, 0x35, 0x34, 0x32, 0x45, 0x30, 0x46, 0x43, 0x30, 0x35, 0x37, + 0x34, 0x30, 0x44, 0x31, 0x42, 0x44, 0x39, 0x44, 0x34, 0x39, 0x45, 0x33, + 0x43, 0x36, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x34, 0x30, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x45, 0x39, 0x34, 0x31, 0x31, 0x39, + 0x44, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x34, + 0x42, 0x35, 0x32, 0x33, 0x46, 0x31, 0x45, 0x34, 0x30, 0x39, 0x45, 0x30, + 0x30, 0x42, 0x33, 0x42, 0x30, 0x46, 0x41, 0x36, 0x39, 0x34, 0x43, 0x34, + 0x30, 0x36, 0x34, 0x44, 0x44, 0x31, 0x38, 0x38, 0x41, 0x42, 0x31, 0x35, + 0x36, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x34, 0x30, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x39, 0x30, 0x46, 0x42, 0x45, 0x41, + 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x30, 0x35, + 0x30, 0x30, 0x46, 0x45, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x43, 0x33, 0x46, 0x42, 0x45, 0x35, 0x42, 0x34, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x34, 0x34, 0x35, 0x36, 0x44, + 0x35, 0x30, 0x34, 0x30, 0x0a, 0x34, 0x30, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x43, 0x36, 0x46, 0x39, 0x30, 0x31, 0x31, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x30, 0x32, + 0x44, 0x39, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x35, 0x46, 0x31, 0x44, 0x34, 0x42, 0x33, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x32, 0x45, 0x39, 0x45, 0x35, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x43, 0x31, 0x46, + 0x33, 0x45, 0x41, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x31, 0x46, 0x43, 0x31, 0x32, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x36, 0x36, 0x32, 0x33, 0x34, 0x30, 0x33, 0x35, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x38, 0x33, + 0x37, 0x42, 0x30, 0x32, 0x36, 0x34, 0x30, 0x0a, 0x34, 0x31, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x41, 0x44, 0x31, 0x32, + 0x36, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x34, 0x34, 0x33, 0x31, 0x41, 0x39, 0x31, 0x41, 0x34, 0x30, 0x39, 0x44, + 0x45, 0x31, 0x45, 0x37, 0x31, 0x33, 0x32, 0x45, 0x39, 0x37, 0x35, 0x35, + 0x34, 0x30, 0x31, 0x45, 0x33, 0x32, 0x42, 0x37, 0x46, 0x30, 0x41, 0x41, + 0x42, 0x41, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x34, 0x31, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x39, 0x45, 0x36, 0x37, + 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, + 0x35, 0x39, 0x45, 0x38, 0x32, 0x34, 0x45, 0x34, 0x30, 0x45, 0x33, 0x41, + 0x32, 0x39, 0x41, 0x41, 0x35, 0x33, 0x39, 0x43, 0x31, 0x34, 0x46, 0x34, + 0x30, 0x34, 0x43, 0x39, 0x43, 0x38, 0x34, 0x32, 0x35, 0x37, 0x39, 0x43, + 0x42, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x34, 0x31, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x45, 0x31, 0x36, 0x39, 0x31, 0x43, 0x46, + 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x42, 0x39, + 0x35, 0x33, 0x39, 0x45, 0x34, 0x34, 0x34, 0x30, 0x34, 0x31, 0x45, 0x31, + 0x41, 0x45, 0x35, 0x39, 0x45, 0x38, 0x35, 0x35, 0x34, 0x30, 0x34, 0x30, + 0x39, 0x43, 0x34, 0x35, 0x33, 0x42, 0x39, 0x33, 0x35, 0x37, 0x32, 0x31, + 0x32, 0x44, 0x34, 0x30, 0x0a, 0x34, 0x31, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x37, 0x42, 0x34, 0x43, 0x45, 0x46, + 0x32, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x39, 0x37, 0x33, + 0x30, 0x43, 0x30, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x41, 0x30, 0x46, 0x44, 0x45, 0x32, 0x34, 0x35, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x43, 0x35, 0x33, 0x41, 0x36, 0x42, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x42, 0x38, 0x41, + 0x39, 0x38, 0x43, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x34, 0x36, 0x42, 0x43, 0x39, 0x30, 0x46, 0x35, 0x34, 0x34, 0x30, 0x0a, + 0x34, 0x31, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x46, 0x38, 0x45, 0x33, 0x37, 0x45, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x43, 0x35, 0x35, 0x44, 0x32, 0x46, 0x42, 0x34, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x39, 0x44, 0x36, 0x41, + 0x44, 0x38, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x34, 0x46, 0x39, 0x45, 0x41, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x32, 0x34, 0x30, 0x31, 0x32, 0x41, 0x32, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x43, 0x33, 0x34, 0x38, + 0x31, 0x32, 0x32, 0x43, 0x34, 0x30, 0x0a, 0x34, 0x31, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, 0x46, 0x34, 0x36, 0x45, + 0x33, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x45, + 0x42, 0x45, 0x35, 0x41, 0x32, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x34, 0x32, 0x42, 0x39, 0x37, 0x35, 0x42, 0x34, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x35, 0x43, 0x31, + 0x33, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x30, + 0x41, 0x41, 0x38, 0x33, 0x44, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x38, 0x32, 0x30, 0x38, 0x35, 0x36, 0x36, 0x34, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x31, 0x30, 0x31, 0x34, 0x36, + 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, + 0x41, 0x38, 0x42, 0x42, 0x35, 0x30, 0x30, 0x34, 0x30, 0x0a, 0x34, 0x31, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x34, 0x35, + 0x36, 0x30, 0x43, 0x39, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x43, 0x31, 0x33, 0x31, 0x36, 0x30, 0x32, 0x35, 0x30, 0x34, 0x30, + 0x45, 0x41, 0x30, 0x35, 0x45, 0x34, 0x38, 0x31, 0x37, 0x30, 0x41, 0x44, + 0x35, 0x34, 0x34, 0x30, 0x42, 0x30, 0x42, 0x37, 0x37, 0x37, 0x39, 0x43, + 0x38, 0x32, 0x46, 0x32, 0x34, 0x41, 0x34, 0x30, 0x0a, 0x34, 0x31, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x36, 0x46, + 0x32, 0x43, 0x39, 0x31, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x38, 0x41, 0x36, 0x31, 0x43, 0x37, 0x44, 0x33, 0x36, 0x34, 0x30, 0x33, + 0x35, 0x31, 0x39, 0x36, 0x42, 0x41, 0x45, 0x35, 0x32, 0x31, 0x42, 0x33, + 0x30, 0x34, 0x30, 0x42, 0x35, 0x37, 0x39, 0x45, 0x33, 0x34, 0x36, 0x33, + 0x39, 0x42, 0x30, 0x34, 0x33, 0x34, 0x30, 0x0a, 0x34, 0x31, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, 0x43, 0x46, 0x33, 0x34, + 0x46, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x45, + 0x43, 0x31, 0x42, 0x36, 0x39, 0x36, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x39, 0x41, 0x33, 0x39, 0x45, 0x37, 0x33, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x39, 0x32, 0x41, + 0x37, 0x37, 0x34, 0x42, 0x34, 0x30, 0x34, 0x45, 0x31, 0x31, 0x36, 0x44, + 0x36, 0x42, 0x38, 0x36, 0x39, 0x30, 0x33, 0x44, 0x34, 0x30, 0x44, 0x43, + 0x44, 0x42, 0x42, 0x46, 0x46, 0x46, 0x42, 0x44, 0x36, 0x35, 0x34, 0x37, + 0x34, 0x30, 0x0a, 0x34, 0x31, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x43, 0x30, 0x31, 0x43, 0x45, 0x41, 0x44, 0x34, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x41, 0x31, 0x34, 0x38, 0x42, + 0x33, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, + 0x33, 0x45, 0x45, 0x41, 0x30, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x36, 0x46, 0x46, 0x34, 0x34, 0x46, 0x38, 0x35, 0x38, 0x34, + 0x30, 0x43, 0x35, 0x43, 0x37, 0x35, 0x45, 0x30, 0x45, 0x46, 0x45, 0x43, + 0x45, 0x34, 0x32, 0x34, 0x30, 0x43, 0x33, 0x43, 0x44, 0x30, 0x34, 0x44, + 0x31, 0x42, 0x41, 0x30, 0x41, 0x34, 0x42, 0x34, 0x30, 0x0a, 0x34, 0x32, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x34, 0x46, + 0x31, 0x46, 0x41, 0x42, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x30, 0x36, 0x33, 0x30, 0x46, 0x44, 0x36, 0x32, 0x31, 0x34, 0x30, + 0x33, 0x43, 0x33, 0x35, 0x45, 0x45, 0x37, 0x34, 0x32, 0x32, 0x44, 0x38, + 0x34, 0x42, 0x34, 0x30, 0x37, 0x30, 0x38, 0x38, 0x44, 0x31, 0x43, 0x43, + 0x39, 0x39, 0x35, 0x42, 0x34, 0x39, 0x34, 0x30, 0x0a, 0x34, 0x32, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x37, 0x37, + 0x33, 0x31, 0x43, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x38, 0x37, 0x45, 0x37, 0x39, 0x33, 0x38, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x38, 0x31, 0x37, 0x36, 0x38, 0x32, 0x35, 0x33, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x32, 0x34, 0x46, + 0x33, 0x44, 0x34, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x34, 0x35, 0x34, 0x35, 0x33, 0x42, 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x35, 0x45, 0x43, 0x43, 0x43, 0x31, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x34, 0x41, + 0x36, 0x33, 0x36, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x33, 0x35, 0x44, 0x38, 0x37, 0x35, 0x35, 0x32, 0x34, 0x30, 0x0a, + 0x34, 0x32, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, + 0x43, 0x43, 0x34, 0x34, 0x43, 0x37, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x34, 0x46, 0x41, 0x41, 0x41, 0x37, 0x39, 0x34, 0x31, + 0x34, 0x30, 0x46, 0x33, 0x37, 0x41, 0x43, 0x31, 0x41, 0x42, 0x34, 0x37, + 0x35, 0x43, 0x34, 0x42, 0x34, 0x30, 0x31, 0x33, 0x30, 0x46, 0x46, 0x46, + 0x36, 0x33, 0x42, 0x30, 0x42, 0x44, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x34, + 0x32, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x32, + 0x38, 0x44, 0x38, 0x35, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x30, 0x33, 0x33, 0x33, 0x31, 0x45, 0x42, 0x33, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x36, 0x33, 0x32, 0x34, 0x41, + 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x34, 0x37, + 0x35, 0x39, 0x44, 0x31, 0x46, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x34, 0x32, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x41, 0x30, + 0x37, 0x37, 0x43, 0x31, 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x30, 0x36, 0x39, 0x42, 0x34, 0x37, 0x37, 0x34, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x45, 0x35, 0x39, 0x33, 0x42, 0x39, 0x35, + 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x33, 0x31, + 0x34, 0x34, 0x31, 0x35, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x38, 0x32, 0x36, 0x42, 0x36, 0x44, 0x34, 0x33, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x31, 0x38, 0x36, 0x44, 0x38, + 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x45, + 0x41, 0x34, 0x41, 0x30, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x45, 0x41, 0x35, 0x42, 0x42, 0x30, 0x31, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x42, 0x37, 0x44, 0x34, 0x46, 0x45, + 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x33, + 0x31, 0x41, 0x31, 0x31, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x34, 0x32, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, 0x36, 0x34, 0x39, + 0x42, 0x46, 0x35, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x34, 0x33, 0x35, 0x33, 0x35, 0x30, 0x37, 0x34, 0x46, 0x34, 0x30, 0x31, + 0x33, 0x31, 0x34, 0x43, 0x44, 0x35, 0x43, 0x44, 0x37, 0x35, 0x39, 0x35, + 0x32, 0x34, 0x30, 0x44, 0x41, 0x45, 0x37, 0x44, 0x44, 0x42, 0x33, 0x39, + 0x39, 0x39, 0x44, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x34, 0x32, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x38, 0x41, 0x32, 0x38, + 0x43, 0x36, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x32, 0x37, 0x31, 0x34, 0x35, 0x45, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x31, 0x44, 0x44, 0x37, 0x34, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x36, 0x43, 0x36, 0x34, 0x37, + 0x32, 0x41, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, + 0x32, 0x41, 0x44, 0x33, 0x42, 0x35, 0x31, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x41, 0x30, 0x45, 0x35, 0x42, 0x45, 0x36, 0x35, 0x30, + 0x34, 0x30, 0x0a, 0x34, 0x32, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x34, 0x35, 0x35, 0x35, 0x46, 0x30, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x30, 0x42, 0x45, 0x33, 0x39, + 0x31, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x31, + 0x32, 0x43, 0x41, 0x37, 0x43, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x42, 0x42, 0x41, 0x39, 0x30, 0x44, 0x34, 0x38, 0x34, + 0x30, 0x35, 0x42, 0x41, 0x41, 0x33, 0x36, 0x36, 0x42, 0x35, 0x39, 0x42, + 0x45, 0x35, 0x32, 0x34, 0x30, 0x42, 0x39, 0x31, 0x37, 0x34, 0x41, 0x31, + 0x35, 0x46, 0x45, 0x41, 0x42, 0x34, 0x39, 0x34, 0x30, 0x0a, 0x34, 0x32, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x43, 0x32, + 0x30, 0x35, 0x41, 0x37, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x38, 0x38, 0x38, 0x38, 0x44, 0x33, 0x42, 0x33, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x45, 0x37, 0x43, 0x43, 0x38, + 0x46, 0x38, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x42, 0x41, + 0x34, 0x30, 0x35, 0x35, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x41, 0x36, 0x31, 0x44, 0x35, 0x37, 0x32, 0x35, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x38, 0x46, 0x46, 0x38, 0x36, 0x36, + 0x35, 0x36, 0x34, 0x30, 0x0a, 0x34, 0x32, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x32, 0x46, 0x38, 0x41, 0x35, 0x46, 0x44, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x45, 0x34, 0x45, 0x43, + 0x43, 0x42, 0x33, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x43, 0x45, 0x44, 0x37, 0x38, 0x46, 0x39, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x41, 0x36, 0x32, 0x45, 0x42, 0x35, 0x33, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x36, 0x33, 0x31, 0x46, + 0x34, 0x33, 0x46, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x43, 0x36, 0x37, 0x36, 0x39, 0x36, 0x34, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x38, 0x39, 0x45, 0x46, 0x45, 0x44, 0x42, 0x33, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x36, 0x33, 0x42, 0x37, + 0x39, 0x39, 0x37, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x34, 0x33, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x45, 0x34, 0x37, + 0x36, 0x31, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x41, 0x30, 0x39, 0x42, 0x42, 0x35, 0x46, 0x30, 0x33, 0x46, 0x35, 0x46, + 0x43, 0x41, 0x32, 0x43, 0x44, 0x41, 0x46, 0x36, 0x32, 0x38, 0x32, 0x32, + 0x34, 0x30, 0x37, 0x34, 0x38, 0x31, 0x43, 0x31, 0x34, 0x44, 0x43, 0x39, + 0x34, 0x46, 0x34, 0x30, 0x34, 0x30, 0x0a, 0x34, 0x33, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x35, 0x37, 0x38, 0x32, 0x42, + 0x36, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x30, + 0x39, 0x35, 0x38, 0x34, 0x46, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x38, 0x30, 0x38, 0x43, 0x32, 0x44, 0x45, 0x33, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x34, 0x38, 0x34, 0x45, 0x42, + 0x36, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, + 0x43, 0x35, 0x44, 0x46, 0x36, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x30, 0x43, 0x38, 0x32, 0x37, 0x30, 0x44, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x32, 0x46, 0x39, 0x32, 0x37, + 0x43, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x41, + 0x35, 0x46, 0x38, 0x38, 0x33, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x34, 0x33, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x34, 0x45, + 0x38, 0x33, 0x34, 0x41, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x34, 0x39, 0x39, 0x39, 0x32, 0x46, 0x36, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x33, 0x46, 0x30, 0x46, 0x37, 0x37, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x44, 0x35, + 0x33, 0x37, 0x36, 0x34, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x38, 0x45, 0x39, 0x30, 0x38, 0x44, 0x33, 0x33, 0x39, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x34, 0x33, 0x46, 0x35, 0x39, 0x35, + 0x34, 0x44, 0x34, 0x30, 0x0a, 0x34, 0x33, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x36, 0x41, 0x45, 0x36, 0x34, 0x33, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x34, 0x39, 0x46, + 0x41, 0x30, 0x31, 0x35, 0x35, 0x34, 0x30, 0x33, 0x32, 0x32, 0x33, 0x33, + 0x39, 0x30, 0x38, 0x41, 0x30, 0x34, 0x35, 0x34, 0x43, 0x34, 0x30, 0x31, + 0x37, 0x46, 0x42, 0x45, 0x42, 0x30, 0x41, 0x34, 0x41, 0x45, 0x30, 0x35, + 0x31, 0x34, 0x30, 0x0a, 0x34, 0x33, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x38, 0x33, 0x44, 0x38, 0x33, 0x35, 0x42, 0x34, 0x43, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x34, 0x30, 0x36, 0x42, + 0x34, 0x39, 0x34, 0x34, 0x34, 0x30, 0x39, 0x45, 0x42, 0x35, 0x31, 0x44, + 0x37, 0x36, 0x37, 0x38, 0x37, 0x37, 0x34, 0x35, 0x34, 0x30, 0x38, 0x41, + 0x46, 0x36, 0x32, 0x42, 0x41, 0x35, 0x32, 0x30, 0x45, 0x41, 0x34, 0x42, + 0x34, 0x30, 0x0a, 0x34, 0x33, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x38, 0x36, 0x44, 0x37, 0x42, 0x37, 0x34, 0x34, 0x41, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, 0x43, 0x38, 0x44, 0x30, + 0x34, 0x32, 0x35, 0x34, 0x30, 0x46, 0x45, 0x42, 0x31, 0x44, 0x46, 0x41, + 0x36, 0x44, 0x42, 0x32, 0x45, 0x35, 0x30, 0x34, 0x30, 0x35, 0x43, 0x39, + 0x43, 0x39, 0x36, 0x35, 0x45, 0x31, 0x41, 0x43, 0x42, 0x33, 0x41, 0x34, + 0x30, 0x0a, 0x34, 0x33, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x39, 0x32, 0x39, 0x30, 0x44, 0x33, 0x32, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x34, 0x45, 0x39, 0x32, 0x30, 0x43, + 0x34, 0x32, 0x34, 0x30, 0x32, 0x35, 0x36, 0x38, 0x39, 0x31, 0x35, 0x46, + 0x36, 0x30, 0x39, 0x36, 0x33, 0x43, 0x34, 0x30, 0x33, 0x34, 0x46, 0x34, + 0x34, 0x34, 0x33, 0x41, 0x38, 0x42, 0x38, 0x30, 0x34, 0x46, 0x34, 0x30, + 0x0a, 0x34, 0x33, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x38, 0x30, 0x41, 0x32, 0x32, 0x42, 0x32, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x38, 0x35, 0x35, 0x34, 0x38, 0x31, 0x46, 0x34, + 0x41, 0x34, 0x30, 0x37, 0x38, 0x35, 0x45, 0x38, 0x35, 0x33, 0x42, 0x36, + 0x30, 0x38, 0x43, 0x32, 0x45, 0x34, 0x30, 0x42, 0x45, 0x43, 0x39, 0x43, + 0x33, 0x44, 0x33, 0x35, 0x36, 0x32, 0x45, 0x34, 0x45, 0x34, 0x30, 0x0a, + 0x34, 0x33, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, + 0x44, 0x35, 0x36, 0x46, 0x44, 0x37, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x34, 0x44, 0x39, 0x44, 0x36, 0x34, 0x33, 0x35, 0x32, + 0x34, 0x30, 0x45, 0x42, 0x41, 0x37, 0x33, 0x31, 0x37, 0x39, 0x46, 0x31, + 0x32, 0x36, 0x35, 0x31, 0x34, 0x30, 0x33, 0x42, 0x31, 0x34, 0x45, 0x33, + 0x33, 0x39, 0x41, 0x42, 0x45, 0x34, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x34, + 0x33, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x45, 0x41, + 0x46, 0x38, 0x36, 0x44, 0x45, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x45, 0x31, 0x35, 0x34, 0x43, 0x31, 0x32, 0x35, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, 0x38, 0x39, 0x30, 0x42, + 0x30, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x46, + 0x46, 0x46, 0x41, 0x45, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x38, 0x38, 0x30, 0x45, 0x30, 0x34, 0x33, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x32, 0x42, 0x37, 0x30, 0x39, + 0x42, 0x34, 0x39, 0x34, 0x30, 0x42, 0x45, 0x33, 0x42, 0x31, 0x32, 0x41, + 0x32, 0x41, 0x45, 0x34, 0x34, 0x34, 0x36, 0x34, 0x30, 0x43, 0x35, 0x46, + 0x39, 0x46, 0x46, 0x33, 0x31, 0x36, 0x41, 0x38, 0x34, 0x34, 0x34, 0x34, + 0x30, 0x0a, 0x34, 0x34, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x32, 0x43, 0x34, 0x32, 0x35, 0x45, 0x42, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x41, 0x32, 0x32, 0x45, 0x30, 0x42, 0x45, + 0x35, 0x30, 0x34, 0x30, 0x36, 0x35, 0x37, 0x31, 0x44, 0x38, 0x42, 0x46, + 0x41, 0x42, 0x36, 0x43, 0x35, 0x35, 0x34, 0x30, 0x46, 0x30, 0x38, 0x30, + 0x43, 0x32, 0x33, 0x35, 0x43, 0x38, 0x44, 0x33, 0x35, 0x30, 0x34, 0x30, + 0x0a, 0x34, 0x34, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x38, 0x38, 0x43, 0x32, 0x33, 0x34, 0x42, 0x33, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x31, 0x43, 0x31, 0x43, 0x42, 0x32, + 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x45, 0x39, 0x39, + 0x34, 0x33, 0x31, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x44, 0x32, 0x45, 0x42, 0x36, 0x43, 0x34, 0x46, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x43, 0x37, 0x39, 0x41, 0x45, 0x33, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x44, 0x39, 0x42, + 0x36, 0x35, 0x38, 0x32, 0x45, 0x34, 0x30, 0x0a, 0x34, 0x34, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, 0x35, 0x39, 0x32, + 0x31, 0x36, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, + 0x38, 0x32, 0x35, 0x46, 0x38, 0x34, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x38, 0x36, 0x36, 0x33, 0x31, 0x34, 0x30, 0x35, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x34, 0x36, 0x46, 0x37, + 0x46, 0x35, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, + 0x37, 0x44, 0x42, 0x38, 0x39, 0x30, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, 0x34, 0x45, 0x46, 0x35, 0x37, + 0x34, 0x30, 0x0a, 0x34, 0x34, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x32, 0x43, 0x33, 0x45, 0x44, 0x45, 0x37, 0x35, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x46, 0x44, 0x34, 0x45, + 0x45, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, + 0x35, 0x39, 0x43, 0x35, 0x32, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x43, 0x45, 0x35, 0x43, 0x44, 0x41, 0x36, 0x35, 0x30, 0x34, + 0x30, 0x0a, 0x34, 0x34, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x31, 0x38, 0x42, 0x36, 0x34, 0x32, 0x35, 0x34, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x46, 0x41, 0x42, 0x37, 0x44, 0x38, + 0x32, 0x42, 0x34, 0x30, 0x31, 0x33, 0x43, 0x36, 0x31, 0x42, 0x34, 0x45, + 0x38, 0x32, 0x33, 0x41, 0x34, 0x45, 0x34, 0x30, 0x42, 0x39, 0x42, 0x34, + 0x31, 0x45, 0x33, 0x44, 0x37, 0x30, 0x46, 0x32, 0x32, 0x38, 0x34, 0x30, + 0x0a, 0x34, 0x34, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x34, 0x34, 0x35, 0x34, 0x42, 0x45, 0x43, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x38, 0x34, 0x38, 0x38, 0x44, + 0x30, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x38, 0x36, 0x46, + 0x44, 0x44, 0x34, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x34, 0x30, 0x44, 0x46, 0x36, 0x35, 0x43, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x41, 0x42, 0x39, 0x35, 0x30, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x32, 0x46, + 0x32, 0x39, 0x46, 0x34, 0x34, 0x34, 0x30, 0x45, 0x36, 0x35, 0x35, 0x45, + 0x46, 0x38, 0x43, 0x32, 0x38, 0x36, 0x38, 0x34, 0x33, 0x34, 0x30, 0x42, + 0x46, 0x38, 0x39, 0x34, 0x45, 0x43, 0x43, 0x45, 0x43, 0x36, 0x46, 0x34, + 0x43, 0x34, 0x30, 0x0a, 0x34, 0x34, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x32, 0x46, 0x30, 0x35, 0x44, 0x30, 0x34, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x33, 0x33, 0x44, 0x37, + 0x43, 0x39, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x32, 0x37, 0x32, 0x39, 0x37, 0x36, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x43, 0x38, 0x37, 0x38, 0x41, 0x45, 0x37, 0x34, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x42, 0x39, 0x32, 0x37, + 0x39, 0x32, 0x33, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x42, 0x34, 0x42, 0x36, 0x36, 0x30, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x34, + 0x34, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x45, + 0x35, 0x43, 0x44, 0x44, 0x32, 0x34, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x43, 0x32, 0x34, 0x30, 0x36, 0x45, 0x37, 0x34, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x35, 0x43, 0x33, 0x32, 0x30, + 0x39, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x43, + 0x31, 0x37, 0x33, 0x34, 0x39, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x43, 0x41, 0x37, 0x44, 0x42, 0x36, 0x33, 0x34, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x43, 0x45, 0x39, 0x31, 0x43, + 0x33, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x43, + 0x41, 0x38, 0x34, 0x36, 0x41, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x42, 0x33, 0x44, 0x36, 0x30, 0x44, 0x34, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x37, 0x41, 0x35, 0x46, 0x31, + 0x46, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, + 0x31, 0x43, 0x35, 0x35, 0x46, 0x31, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x38, 0x33, 0x45, 0x34, 0x35, 0x36, 0x35, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x46, 0x45, 0x39, 0x32, 0x44, + 0x45, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x34, 0x34, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x42, 0x31, 0x32, 0x44, 0x31, 0x38, + 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x39, + 0x44, 0x31, 0x31, 0x36, 0x33, 0x32, 0x34, 0x30, 0x45, 0x43, 0x46, 0x45, + 0x41, 0x44, 0x36, 0x30, 0x39, 0x30, 0x37, 0x38, 0x34, 0x33, 0x34, 0x30, + 0x41, 0x36, 0x34, 0x33, 0x35, 0x46, 0x42, 0x39, 0x45, 0x31, 0x31, 0x34, + 0x33, 0x42, 0x34, 0x30, 0x0a, 0x34, 0x34, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x38, 0x35, 0x36, 0x43, 0x42, 0x30, 0x33, 0x34, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x35, 0x34, 0x35, + 0x39, 0x43, 0x41, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x43, 0x42, 0x43, 0x45, 0x30, 0x36, 0x45, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x30, 0x45, 0x30, 0x43, 0x39, 0x42, 0x34, 0x31, + 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x43, 0x44, 0x42, + 0x38, 0x37, 0x42, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x35, 0x33, 0x43, 0x46, 0x39, 0x42, 0x32, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x46, 0x44, 0x30, 0x43, 0x32, 0x30, 0x34, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x33, 0x41, 0x43, + 0x41, 0x36, 0x46, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x34, 0x35, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x45, 0x34, 0x34, 0x38, + 0x34, 0x35, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x41, 0x32, 0x41, 0x43, 0x42, 0x35, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x43, 0x35, 0x45, 0x45, 0x31, 0x44, 0x32, 0x43, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, 0x33, 0x34, 0x34, 0x35, + 0x43, 0x42, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x45, + 0x31, 0x37, 0x39, 0x41, 0x43, 0x44, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x42, 0x42, 0x38, 0x36, 0x31, 0x32, 0x32, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x30, 0x31, 0x46, 0x46, + 0x32, 0x31, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x39, 0x36, 0x34, 0x45, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x37, 0x37, 0x31, 0x34, 0x41, 0x30, 0x33, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x41, 0x31, 0x43, 0x33, + 0x31, 0x42, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x34, 0x35, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x32, 0x32, 0x35, 0x31, 0x37, + 0x37, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x38, + 0x31, 0x43, 0x31, 0x35, 0x35, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x30, 0x37, 0x44, 0x43, 0x33, 0x39, 0x44, 0x34, 0x46, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x36, 0x34, 0x41, 0x34, 0x42, + 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x45, + 0x43, 0x41, 0x43, 0x32, 0x42, 0x32, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x34, 0x35, 0x44, 0x38, 0x46, 0x46, 0x33, 0x34, 0x46, 0x34, + 0x30, 0x0a, 0x34, 0x35, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x31, 0x31, 0x43, 0x35, 0x44, 0x32, 0x31, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x44, 0x43, 0x36, 0x42, 0x32, 0x33, 0x39, 0x37, + 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, + 0x37, 0x42, 0x44, 0x33, 0x42, 0x30, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x43, 0x39, 0x31, 0x35, 0x30, 0x35, 0x31, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x32, 0x44, 0x31, 0x32, 0x33, 0x32, + 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x33, 0x33, + 0x38, 0x45, 0x43, 0x45, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x38, 0x31, 0x33, 0x32, 0x34, 0x35, 0x45, 0x33, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x36, 0x39, 0x41, 0x42, 0x30, 0x38, + 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, + 0x44, 0x35, 0x31, 0x38, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x38, 0x42, 0x44, 0x30, 0x42, 0x32, 0x43, 0x33, 0x45, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x34, 0x35, 0x43, 0x39, 0x34, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x41, 0x34, + 0x41, 0x36, 0x45, 0x31, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x45, 0x34, 0x44, 0x36, 0x31, 0x45, 0x46, 0x35, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x31, 0x38, 0x41, 0x35, 0x44, 0x39, + 0x35, 0x33, 0x34, 0x30, 0x0a, 0x34, 0x35, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x32, 0x36, 0x31, 0x46, 0x37, 0x33, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x45, 0x34, 0x43, 0x45, + 0x41, 0x41, 0x34, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x32, 0x32, 0x34, 0x30, 0x34, 0x32, 0x45, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x43, 0x46, 0x44, 0x36, 0x46, 0x44, 0x35, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x34, 0x41, + 0x37, 0x44, 0x37, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x30, 0x30, 0x38, 0x35, 0x34, 0x41, 0x38, 0x34, 0x32, 0x34, 0x30, 0x0a, + 0x34, 0x35, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x32, + 0x39, 0x44, 0x43, 0x42, 0x43, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x38, 0x43, 0x34, 0x41, 0x41, 0x34, 0x45, 0x34, 0x43, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x35, 0x41, 0x33, 0x42, + 0x46, 0x32, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, + 0x33, 0x46, 0x31, 0x41, 0x33, 0x33, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x30, 0x38, 0x34, 0x44, 0x43, 0x44, 0x38, 0x33, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x45, 0x46, 0x46, 0x42, + 0x32, 0x44, 0x30, 0x41, 0x34, 0x30, 0x0a, 0x34, 0x35, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x44, 0x30, 0x46, 0x45, 0x45, + 0x46, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x31, + 0x45, 0x30, 0x32, 0x36, 0x43, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x34, 0x30, 0x45, 0x32, 0x46, 0x42, 0x43, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x41, 0x33, 0x42, 0x32, 0x32, 0x38, + 0x37, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x46, + 0x44, 0x33, 0x36, 0x37, 0x30, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x37, 0x32, 0x37, 0x35, 0x34, 0x44, 0x31, 0x36, 0x34, + 0x30, 0x42, 0x41, 0x41, 0x37, 0x38, 0x33, 0x42, 0x37, 0x38, 0x38, 0x36, + 0x36, 0x35, 0x30, 0x34, 0x30, 0x43, 0x36, 0x39, 0x41, 0x34, 0x33, 0x39, + 0x32, 0x30, 0x33, 0x39, 0x30, 0x32, 0x45, 0x34, 0x30, 0x0a, 0x34, 0x35, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, 0x38, + 0x30, 0x34, 0x32, 0x35, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x31, 0x30, 0x39, 0x45, 0x37, 0x34, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x46, 0x45, 0x31, 0x44, 0x34, 0x46, + 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x38, 0x32, + 0x42, 0x32, 0x44, 0x44, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x30, 0x31, 0x31, 0x41, 0x37, 0x46, 0x35, 0x34, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, 0x41, 0x33, 0x42, 0x46, 0x35, + 0x31, 0x33, 0x34, 0x30, 0x0a, 0x34, 0x35, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x30, 0x38, 0x43, 0x46, 0x44, 0x43, 0x45, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x36, 0x32, + 0x33, 0x46, 0x33, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x38, 0x32, 0x46, 0x38, 0x38, 0x43, 0x34, 0x33, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x38, 0x44, 0x45, 0x41, 0x35, 0x45, 0x43, 0x34, + 0x35, 0x34, 0x30, 0x36, 0x33, 0x45, 0x42, 0x31, 0x45, 0x42, 0x34, 0x43, + 0x32, 0x31, 0x32, 0x34, 0x39, 0x34, 0x30, 0x36, 0x45, 0x38, 0x36, 0x44, + 0x30, 0x42, 0x41, 0x42, 0x42, 0x45, 0x39, 0x34, 0x43, 0x34, 0x30, 0x0a, + 0x34, 0x35, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x44, 0x41, 0x38, 0x33, 0x39, 0x37, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x37, 0x32, 0x41, 0x43, 0x38, 0x45, 0x33, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, 0x30, 0x35, 0x31, 0x46, + 0x34, 0x37, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, + 0x33, 0x37, 0x45, 0x31, 0x32, 0x41, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x43, 0x44, 0x46, 0x41, 0x43, 0x30, 0x37, 0x34, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x33, 0x42, 0x34, 0x42, + 0x32, 0x35, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, + 0x35, 0x33, 0x33, 0x31, 0x30, 0x45, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x30, 0x44, 0x45, 0x35, 0x44, 0x41, 0x31, 0x33, 0x30, + 0x34, 0x30, 0x45, 0x39, 0x37, 0x39, 0x31, 0x41, 0x39, 0x41, 0x36, 0x34, + 0x35, 0x32, 0x34, 0x31, 0x34, 0x30, 0x43, 0x34, 0x35, 0x36, 0x46, 0x35, + 0x34, 0x42, 0x42, 0x33, 0x36, 0x33, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x34, + 0x35, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x33, + 0x41, 0x39, 0x31, 0x42, 0x43, 0x33, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x43, 0x35, 0x31, 0x34, 0x37, 0x35, 0x36, 0x34, 0x45, 0x34, + 0x30, 0x42, 0x35, 0x34, 0x34, 0x46, 0x45, 0x35, 0x32, 0x41, 0x46, 0x37, + 0x44, 0x33, 0x43, 0x34, 0x30, 0x44, 0x38, 0x44, 0x37, 0x46, 0x44, 0x31, + 0x39, 0x38, 0x30, 0x42, 0x44, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x34, 0x36, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x36, 0x44, + 0x46, 0x41, 0x46, 0x42, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x33, 0x39, 0x44, 0x45, 0x37, 0x30, 0x34, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x35, 0x38, 0x44, 0x36, + 0x44, 0x42, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x32, 0x44, + 0x44, 0x45, 0x32, 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x38, 0x33, 0x39, 0x31, 0x41, 0x39, 0x43, 0x35, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x42, 0x36, 0x43, 0x42, 0x37, 0x45, + 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x37, 0x42, + 0x39, 0x36, 0x41, 0x45, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x30, 0x34, 0x36, 0x38, 0x35, 0x46, 0x46, 0x32, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x31, 0x45, 0x37, 0x35, 0x34, 0x33, + 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x34, 0x41, + 0x35, 0x45, 0x36, 0x42, 0x34, 0x33, 0x34, 0x30, 0x0a, 0x34, 0x36, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x43, 0x31, 0x42, 0x37, + 0x45, 0x39, 0x45, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x38, 0x33, 0x36, 0x35, 0x36, 0x38, 0x38, 0x34, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x30, 0x41, 0x35, 0x45, 0x36, 0x34, 0x42, 0x32, + 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x32, 0x43, 0x32, + 0x38, 0x43, 0x34, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x35, 0x34, 0x44, 0x37, 0x39, 0x32, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x38, 0x42, 0x39, 0x36, 0x37, 0x33, 0x41, 0x34, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x34, 0x42, 0x38, + 0x31, 0x43, 0x44, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x43, 0x46, 0x38, 0x38, 0x46, 0x33, 0x38, 0x35, 0x35, 0x34, 0x30, 0x0a, + 0x34, 0x36, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, + 0x30, 0x38, 0x42, 0x30, 0x37, 0x35, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x31, 0x36, 0x32, 0x30, 0x39, 0x43, 0x33, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x37, 0x34, 0x34, 0x36, + 0x38, 0x33, 0x33, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, + 0x46, 0x33, 0x41, 0x39, 0x42, 0x33, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x45, 0x42, 0x34, 0x38, 0x39, 0x32, 0x35, 0x34, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x34, 0x37, 0x46, 0x44, 0x42, + 0x35, 0x34, 0x34, 0x41, 0x34, 0x30, 0x0a, 0x34, 0x36, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x33, 0x43, 0x31, 0x43, + 0x44, 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, + 0x43, 0x37, 0x32, 0x37, 0x44, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x34, 0x43, 0x36, 0x46, 0x43, 0x33, 0x34, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x32, 0x43, 0x45, 0x45, 0x31, + 0x42, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, + 0x33, 0x44, 0x39, 0x46, 0x32, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x43, 0x43, 0x32, 0x32, 0x36, 0x31, 0x41, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x38, 0x34, 0x43, 0x34, 0x33, + 0x37, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x37, + 0x32, 0x39, 0x34, 0x45, 0x30, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x43, 0x46, 0x37, 0x38, 0x31, 0x36, 0x43, 0x34, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x33, 0x41, 0x36, 0x37, + 0x32, 0x31, 0x37, 0x34, 0x30, 0x0a, 0x34, 0x36, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x34, 0x39, 0x36, 0x33, 0x41, 0x43, + 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x45, + 0x43, 0x39, 0x33, 0x31, 0x34, 0x38, 0x34, 0x30, 0x43, 0x38, 0x32, 0x32, + 0x39, 0x39, 0x39, 0x37, 0x39, 0x43, 0x46, 0x37, 0x34, 0x38, 0x34, 0x30, + 0x42, 0x30, 0x46, 0x31, 0x42, 0x43, 0x44, 0x33, 0x30, 0x39, 0x33, 0x38, + 0x34, 0x46, 0x34, 0x30, 0x0a, 0x34, 0x36, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x30, 0x36, 0x43, 0x33, 0x38, 0x38, 0x41, 0x30, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x42, 0x34, 0x38, + 0x32, 0x37, 0x31, 0x34, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x36, 0x32, 0x37, 0x35, 0x46, 0x35, 0x39, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x33, 0x38, 0x38, 0x34, 0x36, 0x46, 0x34, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x34, 0x31, 0x44, + 0x33, 0x42, 0x42, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x36, 0x41, 0x42, 0x36, 0x44, 0x38, 0x32, 0x31, 0x34, 0x30, 0x0a, + 0x34, 0x36, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x35, 0x39, 0x36, 0x31, 0x36, 0x38, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x41, 0x39, 0x30, 0x33, 0x44, 0x35, 0x35, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x43, 0x44, 0x37, 0x34, + 0x38, 0x42, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x37, 0x44, 0x31, 0x34, 0x35, 0x33, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x34, + 0x36, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x32, + 0x44, 0x39, 0x46, 0x30, 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x36, 0x37, 0x38, 0x30, 0x31, 0x46, 0x32, 0x35, 0x34, + 0x30, 0x45, 0x44, 0x37, 0x30, 0x36, 0x44, 0x37, 0x44, 0x37, 0x34, 0x39, + 0x42, 0x34, 0x30, 0x34, 0x30, 0x42, 0x32, 0x46, 0x38, 0x31, 0x37, 0x34, + 0x33, 0x35, 0x33, 0x36, 0x30, 0x33, 0x34, 0x34, 0x30, 0x0a, 0x34, 0x36, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x43, 0x42, + 0x30, 0x37, 0x37, 0x41, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x30, 0x30, 0x39, 0x39, 0x41, 0x42, 0x35, 0x34, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x33, 0x46, 0x42, 0x39, 0x38, 0x43, + 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x34, + 0x32, 0x37, 0x30, 0x35, 0x33, 0x46, 0x34, 0x30, 0x36, 0x36, 0x31, 0x44, + 0x33, 0x32, 0x35, 0x38, 0x32, 0x30, 0x36, 0x30, 0x34, 0x44, 0x34, 0x30, + 0x32, 0x46, 0x35, 0x32, 0x33, 0x39, 0x31, 0x33, 0x45, 0x46, 0x39, 0x38, + 0x35, 0x30, 0x34, 0x30, 0x0a, 0x34, 0x36, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x44, 0x30, 0x35, 0x42, 0x39, 0x34, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x43, 0x35, 0x42, 0x41, + 0x34, 0x43, 0x34, 0x34, 0x46, 0x34, 0x30, 0x35, 0x31, 0x35, 0x31, 0x44, + 0x43, 0x45, 0x45, 0x41, 0x41, 0x44, 0x45, 0x34, 0x31, 0x34, 0x30, 0x31, + 0x46, 0x46, 0x45, 0x33, 0x37, 0x42, 0x37, 0x34, 0x34, 0x31, 0x45, 0x34, + 0x44, 0x34, 0x30, 0x0a, 0x34, 0x37, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x43, 0x37, 0x38, 0x43, 0x46, 0x37, 0x33, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x32, 0x43, 0x37, 0x33, + 0x44, 0x31, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, + 0x41, 0x36, 0x31, 0x37, 0x30, 0x46, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x32, 0x37, 0x31, 0x39, 0x43, 0x30, 0x41, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x33, 0x38, 0x34, 0x44, + 0x36, 0x42, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x37, 0x32, 0x41, 0x43, 0x46, 0x30, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x34, + 0x37, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x33, + 0x30, 0x34, 0x32, 0x46, 0x42, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x36, 0x36, 0x42, 0x38, 0x45, 0x31, 0x32, 0x35, 0x37, 0x34, + 0x30, 0x41, 0x34, 0x45, 0x31, 0x32, 0x45, 0x31, 0x30, 0x35, 0x46, 0x44, + 0x36, 0x35, 0x33, 0x34, 0x30, 0x45, 0x43, 0x33, 0x36, 0x39, 0x37, 0x46, + 0x41, 0x34, 0x41, 0x30, 0x33, 0x35, 0x34, 0x34, 0x30, 0x0a, 0x34, 0x37, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x45, 0x34, 0x41, + 0x46, 0x34, 0x42, 0x31, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x41, 0x35, 0x35, 0x34, 0x34, 0x44, 0x34, 0x36, 0x34, 0x30, + 0x43, 0x43, 0x42, 0x39, 0x43, 0x44, 0x44, 0x44, 0x33, 0x31, 0x44, 0x33, + 0x34, 0x36, 0x34, 0x30, 0x42, 0x30, 0x38, 0x32, 0x35, 0x38, 0x42, 0x38, + 0x30, 0x39, 0x39, 0x46, 0x33, 0x34, 0x34, 0x30, 0x0a, 0x34, 0x37, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x43, 0x32, 0x42, 0x45, + 0x42, 0x45, 0x39, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x30, 0x46, 0x42, 0x44, 0x34, 0x35, 0x30, 0x32, 0x30, 0x34, 0x30, 0x34, + 0x42, 0x43, 0x34, 0x30, 0x45, 0x34, 0x42, 0x42, 0x31, 0x34, 0x31, 0x34, + 0x31, 0x34, 0x30, 0x42, 0x36, 0x32, 0x45, 0x41, 0x41, 0x36, 0x44, 0x43, + 0x41, 0x44, 0x30, 0x33, 0x41, 0x34, 0x30, 0x0a, 0x34, 0x37, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x32, 0x38, 0x45, 0x46, + 0x44, 0x44, 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, + 0x41, 0x30, 0x42, 0x44, 0x35, 0x33, 0x33, 0x30, 0x34, 0x30, 0x32, 0x39, + 0x35, 0x34, 0x41, 0x41, 0x37, 0x32, 0x43, 0x45, 0x36, 0x44, 0x33, 0x39, + 0x34, 0x30, 0x36, 0x38, 0x37, 0x41, 0x37, 0x37, 0x37, 0x37, 0x44, 0x31, + 0x33, 0x44, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x34, 0x37, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x45, 0x37, 0x30, 0x33, 0x44, + 0x45, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, 0x30, + 0x39, 0x43, 0x39, 0x37, 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x45, 0x32, 0x44, 0x32, 0x46, 0x32, 0x33, 0x46, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x42, 0x37, 0x31, 0x45, + 0x32, 0x34, 0x43, 0x34, 0x30, 0x31, 0x30, 0x44, 0x32, 0x31, 0x46, 0x33, + 0x39, 0x39, 0x32, 0x34, 0x35, 0x34, 0x42, 0x34, 0x30, 0x33, 0x30, 0x42, + 0x38, 0x38, 0x36, 0x43, 0x36, 0x32, 0x38, 0x32, 0x30, 0x34, 0x43, 0x34, + 0x30, 0x0a, 0x34, 0x37, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x36, 0x34, 0x36, 0x39, 0x42, 0x43, 0x32, 0x34, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x30, 0x38, 0x42, 0x46, 0x32, 0x37, + 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x35, + 0x34, 0x41, 0x30, 0x34, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x43, 0x44, 0x31, 0x32, 0x36, 0x46, 0x46, 0x34, 0x36, 0x34, 0x30, + 0x33, 0x37, 0x36, 0x36, 0x43, 0x35, 0x44, 0x33, 0x38, 0x33, 0x35, 0x42, + 0x34, 0x43, 0x34, 0x30, 0x37, 0x31, 0x31, 0x42, 0x42, 0x32, 0x34, 0x42, + 0x30, 0x32, 0x32, 0x38, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x34, 0x37, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x33, 0x37, 0x38, + 0x46, 0x33, 0x30, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x38, 0x35, 0x32, 0x30, 0x37, 0x37, 0x35, 0x33, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x34, 0x43, 0x32, 0x46, 0x44, 0x41, 0x33, 0x34, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x44, 0x42, + 0x31, 0x31, 0x31, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x36, 0x36, 0x32, 0x37, 0x41, 0x30, 0x45, 0x35, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x32, 0x44, 0x45, 0x39, 0x38, 0x45, 0x31, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x35, 0x43, + 0x31, 0x44, 0x45, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x36, 0x39, 0x33, 0x37, 0x41, 0x35, 0x33, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x31, 0x42, 0x32, 0x33, 0x46, 0x30, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x41, 0x46, 0x37, 0x39, + 0x34, 0x39, 0x37, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x30, 0x39, 0x33, 0x45, 0x35, 0x41, 0x39, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x42, 0x39, 0x37, 0x32, 0x34, 0x33, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x39, 0x41, + 0x36, 0x42, 0x32, 0x33, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x43, 0x38, 0x33, 0x31, 0x33, 0x37, 0x38, 0x35, 0x38, 0x34, 0x30, 0x0a, + 0x34, 0x37, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, + 0x30, 0x45, 0x34, 0x34, 0x35, 0x44, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x34, 0x35, 0x31, 0x33, 0x32, 0x34, 0x43, 0x34, 0x32, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x36, 0x33, 0x32, 0x46, + 0x33, 0x46, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x42, 0x31, 0x31, 0x33, 0x34, 0x44, 0x31, 0x46, 0x34, 0x30, 0x0a, 0x34, + 0x37, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x33, 0x45, 0x37, 0x30, 0x44, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x38, 0x34, 0x38, 0x43, 0x39, 0x45, 0x38, 0x34, 0x41, 0x34, + 0x30, 0x39, 0x46, 0x43, 0x35, 0x39, 0x44, 0x30, 0x41, 0x30, 0x37, 0x38, + 0x32, 0x34, 0x30, 0x34, 0x30, 0x35, 0x42, 0x39, 0x36, 0x43, 0x44, 0x33, + 0x45, 0x41, 0x39, 0x41, 0x45, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x34, 0x38, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x41, 0x37, + 0x32, 0x45, 0x33, 0x45, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x34, 0x46, 0x43, 0x37, 0x36, 0x43, 0x34, 0x34, 0x46, 0x34, 0x30, + 0x34, 0x39, 0x31, 0x44, 0x31, 0x42, 0x38, 0x35, 0x46, 0x46, 0x36, 0x33, + 0x34, 0x41, 0x34, 0x30, 0x41, 0x43, 0x41, 0x41, 0x39, 0x41, 0x44, 0x43, + 0x39, 0x30, 0x41, 0x43, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x34, 0x38, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x37, 0x34, + 0x45, 0x33, 0x44, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x34, 0x41, 0x37, 0x41, 0x38, 0x32, 0x43, 0x34, 0x31, 0x34, 0x30, 0x33, + 0x38, 0x33, 0x35, 0x38, 0x38, 0x42, 0x45, 0x45, 0x30, 0x35, 0x43, 0x35, + 0x33, 0x34, 0x30, 0x36, 0x33, 0x44, 0x36, 0x30, 0x39, 0x42, 0x44, 0x33, + 0x32, 0x39, 0x38, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x34, 0x38, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x36, 0x39, 0x32, 0x35, + 0x41, 0x36, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, + 0x32, 0x38, 0x41, 0x36, 0x30, 0x43, 0x33, 0x42, 0x34, 0x30, 0x36, 0x30, + 0x42, 0x41, 0x34, 0x31, 0x35, 0x41, 0x45, 0x44, 0x42, 0x37, 0x35, 0x32, + 0x34, 0x30, 0x34, 0x39, 0x31, 0x33, 0x36, 0x44, 0x33, 0x38, 0x30, 0x35, + 0x36, 0x30, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x34, 0x38, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x46, 0x35, 0x35, 0x31, 0x30, + 0x44, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, + 0x44, 0x44, 0x38, 0x42, 0x43, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x36, 0x31, 0x42, 0x45, 0x33, 0x34, 0x43, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x45, 0x45, 0x34, 0x32, 0x34, + 0x37, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x30, 0x32, 0x31, 0x38, 0x39, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x35, 0x41, 0x32, 0x35, 0x45, 0x46, 0x30, 0x33, + 0x46, 0x0a, 0x34, 0x38, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x34, 0x39, 0x39, 0x45, 0x34, 0x44, 0x33, 0x35, 0x34, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x42, 0x45, 0x39, 0x44, 0x41, 0x46, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x46, 0x31, + 0x37, 0x44, 0x32, 0x36, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x43, 0x36, 0x37, 0x31, 0x37, 0x43, 0x35, 0x34, 0x37, 0x34, 0x30, + 0x0a, 0x34, 0x38, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x32, 0x33, 0x31, 0x43, 0x38, 0x41, 0x31, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x34, 0x34, 0x46, 0x31, 0x38, 0x38, 0x42, 0x34, + 0x37, 0x34, 0x30, 0x35, 0x35, 0x35, 0x37, 0x46, 0x41, 0x38, 0x39, 0x38, + 0x43, 0x42, 0x39, 0x33, 0x34, 0x34, 0x30, 0x35, 0x37, 0x44, 0x44, 0x31, + 0x43, 0x31, 0x38, 0x41, 0x30, 0x31, 0x32, 0x34, 0x45, 0x34, 0x30, 0x0a, + 0x34, 0x38, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, + 0x46, 0x46, 0x41, 0x42, 0x33, 0x36, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x45, 0x33, 0x42, 0x36, 0x35, 0x42, 0x43, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x45, 0x45, 0x34, 0x45, 0x41, + 0x45, 0x42, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, + 0x31, 0x35, 0x41, 0x39, 0x33, 0x45, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x34, + 0x38, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x45, 0x34, + 0x32, 0x43, 0x45, 0x45, 0x33, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x38, 0x34, 0x31, 0x34, 0x38, 0x31, 0x35, 0x33, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x44, 0x38, 0x33, 0x44, 0x41, + 0x45, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x35, + 0x45, 0x42, 0x31, 0x33, 0x30, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x34, 0x38, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x45, + 0x32, 0x30, 0x33, 0x30, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x38, 0x45, 0x39, 0x32, 0x42, 0x37, 0x32, 0x35, 0x32, 0x34, 0x30, + 0x44, 0x36, 0x30, 0x44, 0x42, 0x33, 0x36, 0x30, 0x31, 0x31, 0x32, 0x45, + 0x34, 0x45, 0x34, 0x30, 0x30, 0x46, 0x36, 0x42, 0x32, 0x38, 0x35, 0x45, + 0x35, 0x46, 0x30, 0x33, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x34, 0x38, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x37, + 0x45, 0x39, 0x39, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x43, 0x44, 0x42, 0x45, 0x42, 0x32, 0x39, 0x34, 0x31, 0x34, 0x30, 0x37, + 0x38, 0x35, 0x35, 0x44, 0x46, 0x44, 0x33, 0x37, 0x33, 0x35, 0x31, 0x33, + 0x36, 0x34, 0x30, 0x35, 0x39, 0x45, 0x35, 0x38, 0x37, 0x35, 0x36, 0x39, + 0x33, 0x44, 0x34, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x34, 0x39, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x37, 0x31, 0x30, 0x46, + 0x31, 0x39, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, + 0x34, 0x37, 0x44, 0x30, 0x45, 0x42, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x46, 0x43, 0x32, 0x30, 0x45, 0x32, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x33, 0x44, 0x35, + 0x43, 0x39, 0x34, 0x41, 0x34, 0x30, 0x39, 0x42, 0x37, 0x39, 0x34, 0x34, + 0x30, 0x41, 0x39, 0x32, 0x30, 0x46, 0x34, 0x30, 0x34, 0x30, 0x34, 0x38, + 0x33, 0x32, 0x30, 0x35, 0x30, 0x39, 0x38, 0x41, 0x37, 0x33, 0x34, 0x31, + 0x34, 0x30, 0x0a, 0x34, 0x39, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x45, 0x37, 0x44, 0x42, 0x43, 0x42, 0x33, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x37, 0x36, 0x42, 0x38, + 0x34, 0x45, 0x42, 0x33, 0x46, 0x39, 0x44, 0x35, 0x30, 0x35, 0x38, 0x33, + 0x31, 0x37, 0x38, 0x32, 0x32, 0x35, 0x31, 0x34, 0x30, 0x38, 0x30, 0x33, + 0x37, 0x39, 0x33, 0x42, 0x35, 0x42, 0x37, 0x43, 0x31, 0x33, 0x46, 0x34, + 0x30, 0x0a, 0x34, 0x39, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x30, 0x35, 0x37, 0x36, 0x33, 0x30, 0x36, 0x33, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x46, 0x38, 0x46, 0x36, 0x39, 0x43, + 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x43, 0x46, + 0x31, 0x46, 0x31, 0x38, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x32, 0x36, 0x31, 0x44, 0x38, 0x38, 0x36, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x41, 0x31, 0x30, 0x32, 0x41, 0x30, + 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x41, + 0x37, 0x41, 0x38, 0x39, 0x31, 0x31, 0x34, 0x30, 0x0a, 0x34, 0x39, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x46, 0x39, 0x44, + 0x41, 0x45, 0x31, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x38, 0x35, 0x34, 0x30, 0x34, 0x46, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x38, 0x41, 0x37, 0x32, 0x42, 0x31, 0x35, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x34, 0x45, 0x39, + 0x38, 0x38, 0x32, 0x32, 0x31, 0x34, 0x30, 0x33, 0x43, 0x33, 0x35, 0x39, + 0x36, 0x45, 0x43, 0x30, 0x37, 0x30, 0x42, 0x34, 0x44, 0x34, 0x30, 0x46, + 0x43, 0x42, 0x41, 0x37, 0x41, 0x45, 0x42, 0x41, 0x32, 0x30, 0x32, 0x33, + 0x35, 0x34, 0x30, 0x0a, 0x34, 0x39, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x37, 0x45, 0x43, 0x35, 0x41, 0x42, 0x34, 0x45, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x37, 0x36, 0x37, + 0x44, 0x43, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x36, + 0x46, 0x41, 0x38, 0x33, 0x37, 0x38, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x38, 0x42, 0x44, 0x41, 0x33, 0x33, 0x39, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x36, 0x45, 0x43, 0x36, + 0x43, 0x43, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x31, 0x45, 0x39, 0x41, 0x34, 0x33, 0x30, 0x46, 0x34, 0x30, 0x43, 0x45, + 0x36, 0x36, 0x33, 0x32, 0x43, 0x39, 0x39, 0x46, 0x43, 0x32, 0x35, 0x32, + 0x34, 0x30, 0x33, 0x36, 0x30, 0x46, 0x42, 0x46, 0x41, 0x31, 0x33, 0x31, + 0x37, 0x35, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x34, 0x39, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x34, 0x36, 0x30, 0x41, 0x37, + 0x31, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, + 0x32, 0x36, 0x30, 0x30, 0x38, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x30, 0x46, 0x31, 0x37, 0x37, 0x30, 0x34, 0x30, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x36, 0x41, 0x38, 0x30, 0x31, + 0x42, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x31, + 0x41, 0x30, 0x32, 0x33, 0x38, 0x32, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x34, 0x45, 0x41, 0x33, 0x32, 0x43, 0x37, 0x34, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x42, 0x34, 0x30, 0x42, 0x33, + 0x42, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x32, + 0x36, 0x35, 0x30, 0x34, 0x43, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x45, 0x31, 0x31, 0x42, 0x37, 0x36, 0x34, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x32, 0x39, 0x38, 0x30, 0x32, + 0x41, 0x34, 0x35, 0x34, 0x30, 0x0a, 0x34, 0x39, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x33, 0x36, 0x32, 0x35, 0x46, + 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x35, 0x45, + 0x39, 0x34, 0x37, 0x30, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x44, 0x30, 0x39, 0x46, 0x42, 0x43, 0x39, 0x43, 0x33, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x38, 0x35, 0x38, 0x39, 0x36, 0x41, + 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x36, 0x33, + 0x42, 0x39, 0x39, 0x45, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x32, 0x45, 0x33, 0x32, 0x46, 0x42, 0x31, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x42, 0x36, 0x41, 0x32, 0x31, + 0x31, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x32, 0x30, + 0x32, 0x33, 0x31, 0x43, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x46, 0x37, 0x46, 0x43, 0x45, 0x32, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x46, 0x45, 0x42, 0x31, + 0x45, 0x45, 0x33, 0x46, 0x0a, 0x34, 0x39, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x33, 0x34, 0x32, 0x39, 0x44, 0x36, 0x32, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, 0x46, 0x39, 0x42, + 0x33, 0x43, 0x38, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x34, 0x44, 0x46, 0x31, 0x45, 0x31, 0x37, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x38, 0x33, 0x30, 0x45, 0x36, 0x31, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x45, 0x46, 0x44, + 0x45, 0x33, 0x35, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x35, 0x41, 0x31, 0x43, 0x44, 0x34, 0x33, 0x46, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x43, 0x36, 0x34, 0x32, 0x44, 0x39, 0x39, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x34, 0x45, 0x30, 0x42, + 0x39, 0x41, 0x36, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x37, 0x37, 0x41, 0x36, 0x32, 0x46, 0x34, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x30, 0x44, 0x35, 0x31, 0x42, 0x38, 0x35, 0x35, + 0x36, 0x34, 0x30, 0x0a, 0x34, 0x39, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x38, 0x46, 0x36, 0x45, 0x44, 0x44, 0x46, 0x34, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, 0x33, 0x46, 0x39, 0x43, + 0x41, 0x30, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x44, 0x37, 0x43, 0x30, 0x35, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x38, 0x33, 0x39, 0x43, 0x32, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x41, 0x41, 0x45, 0x35, + 0x45, 0x42, 0x30, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, + 0x32, 0x39, 0x45, 0x36, 0x41, 0x38, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x34, + 0x39, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x38, + 0x34, 0x33, 0x45, 0x30, 0x39, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x30, 0x34, 0x38, 0x37, 0x44, 0x42, 0x46, 0x32, 0x34, 0x34, + 0x30, 0x35, 0x30, 0x33, 0x44, 0x38, 0x44, 0x36, 0x30, 0x32, 0x38, 0x32, + 0x34, 0x34, 0x39, 0x34, 0x30, 0x35, 0x36, 0x41, 0x42, 0x45, 0x43, 0x44, + 0x46, 0x34, 0x45, 0x32, 0x42, 0x34, 0x30, 0x34, 0x30, 0x0a, 0x35, 0x30, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x41, 0x39, + 0x30, 0x37, 0x42, 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x38, 0x32, 0x32, 0x39, 0x34, 0x43, 0x33, 0x34, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x35, 0x45, 0x41, 0x35, 0x36, 0x32, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x30, 0x34, + 0x32, 0x34, 0x43, 0x42, 0x35, 0x38, 0x34, 0x30, 0x42, 0x38, 0x34, 0x41, + 0x37, 0x33, 0x37, 0x44, 0x36, 0x41, 0x42, 0x33, 0x34, 0x37, 0x34, 0x30, + 0x45, 0x37, 0x36, 0x37, 0x44, 0x43, 0x42, 0x42, 0x42, 0x30, 0x33, 0x33, + 0x35, 0x35, 0x34, 0x30, 0x0a, 0x35, 0x30, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x32, 0x46, 0x36, 0x31, 0x46, 0x44, 0x32, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x45, 0x30, 0x30, 0x43, + 0x38, 0x38, 0x35, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x41, 0x37, 0x31, 0x32, 0x41, 0x34, 0x35, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x43, 0x35, 0x35, 0x35, 0x32, 0x34, 0x44, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x31, 0x45, 0x46, + 0x34, 0x31, 0x38, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x32, 0x43, 0x43, 0x32, 0x45, 0x46, 0x34, 0x35, 0x31, 0x34, 0x30, 0x0a, + 0x35, 0x30, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x41, 0x31, 0x35, 0x42, 0x34, 0x30, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x45, 0x38, 0x33, 0x36, 0x36, 0x32, 0x35, 0x38, + 0x34, 0x30, 0x45, 0x38, 0x36, 0x37, 0x42, 0x36, 0x42, 0x30, 0x33, 0x41, + 0x32, 0x42, 0x34, 0x32, 0x34, 0x30, 0x35, 0x31, 0x42, 0x44, 0x46, 0x41, + 0x39, 0x46, 0x45, 0x36, 0x31, 0x39, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x35, + 0x30, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x37, + 0x30, 0x35, 0x44, 0x35, 0x41, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x43, 0x32, 0x43, 0x46, 0x32, 0x33, 0x37, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, 0x41, 0x30, 0x36, 0x36, + 0x41, 0x33, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, + 0x42, 0x41, 0x30, 0x46, 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x34, 0x38, 0x35, 0x35, 0x30, 0x41, 0x39, 0x35, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x41, 0x33, 0x30, 0x39, + 0x34, 0x30, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x36, + 0x43, 0x36, 0x38, 0x37, 0x42, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x43, 0x45, 0x43, 0x46, 0x35, 0x44, 0x43, 0x34, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x44, 0x42, 0x46, 0x33, 0x33, + 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, 0x46, + 0x30, 0x38, 0x36, 0x44, 0x45, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x35, 0x30, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x39, + 0x34, 0x33, 0x30, 0x46, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x34, 0x39, 0x33, 0x33, 0x34, 0x32, 0x32, 0x34, 0x30, + 0x38, 0x32, 0x42, 0x44, 0x38, 0x36, 0x37, 0x34, 0x35, 0x37, 0x39, 0x44, + 0x34, 0x44, 0x34, 0x30, 0x36, 0x41, 0x44, 0x32, 0x46, 0x34, 0x34, 0x35, + 0x39, 0x37, 0x38, 0x37, 0x32, 0x46, 0x34, 0x30, 0x0a, 0x35, 0x30, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x42, 0x36, 0x33, + 0x36, 0x35, 0x31, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x38, 0x43, 0x42, 0x46, 0x36, 0x42, 0x39, 0x35, 0x35, 0x34, 0x30, 0x37, + 0x34, 0x39, 0x41, 0x41, 0x44, 0x42, 0x45, 0x31, 0x35, 0x39, 0x41, 0x32, + 0x46, 0x34, 0x30, 0x38, 0x33, 0x39, 0x44, 0x37, 0x46, 0x41, 0x36, 0x43, + 0x31, 0x32, 0x46, 0x33, 0x43, 0x34, 0x30, 0x0a, 0x35, 0x30, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x42, 0x46, 0x34, 0x38, + 0x44, 0x37, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x34, 0x44, 0x30, 0x36, 0x30, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x41, 0x38, 0x42, 0x33, 0x38, 0x42, 0x42, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, 0x38, 0x31, 0x32, 0x43, + 0x45, 0x41, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, + 0x35, 0x38, 0x36, 0x33, 0x41, 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x44, 0x45, 0x36, 0x34, 0x30, 0x30, 0x33, 0x34, + 0x34, 0x30, 0x44, 0x38, 0x33, 0x33, 0x35, 0x34, 0x32, 0x45, 0x30, 0x46, + 0x43, 0x30, 0x35, 0x37, 0x34, 0x30, 0x44, 0x31, 0x42, 0x44, 0x39, 0x44, + 0x34, 0x39, 0x45, 0x33, 0x43, 0x36, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x35, + 0x30, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x45, 0x39, + 0x34, 0x31, 0x31, 0x39, 0x44, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x34, 0x42, 0x35, 0x32, 0x33, 0x46, 0x31, 0x45, 0x34, + 0x30, 0x39, 0x45, 0x30, 0x30, 0x42, 0x33, 0x42, 0x30, 0x46, 0x41, 0x36, + 0x39, 0x34, 0x43, 0x34, 0x30, 0x36, 0x34, 0x44, 0x44, 0x31, 0x38, 0x38, + 0x41, 0x42, 0x31, 0x35, 0x36, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x35, 0x30, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x39, 0x30, + 0x46, 0x42, 0x45, 0x41, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x43, 0x30, 0x35, 0x30, 0x30, 0x46, 0x45, 0x34, 0x44, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x33, 0x46, 0x42, 0x45, 0x35, 0x42, + 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x34, + 0x34, 0x35, 0x36, 0x44, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x35, 0x30, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x36, 0x46, 0x39, + 0x30, 0x31, 0x31, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x30, 0x31, 0x30, 0x32, 0x44, 0x39, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x35, 0x46, 0x31, 0x44, 0x34, 0x42, 0x33, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x32, 0x45, + 0x39, 0x45, 0x35, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x38, 0x43, 0x31, 0x46, 0x33, 0x45, 0x41, 0x34, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x46, 0x43, 0x31, 0x32, 0x35, 0x34, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x36, 0x36, 0x32, 0x33, + 0x34, 0x30, 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x30, 0x30, 0x38, 0x33, 0x37, 0x42, 0x30, 0x32, 0x36, 0x34, 0x30, 0x0a, + 0x35, 0x31, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, + 0x41, 0x44, 0x31, 0x32, 0x36, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x34, 0x34, 0x33, 0x31, 0x41, 0x39, 0x31, 0x41, + 0x34, 0x30, 0x39, 0x44, 0x45, 0x31, 0x45, 0x37, 0x31, 0x33, 0x32, 0x45, + 0x39, 0x37, 0x35, 0x35, 0x34, 0x30, 0x31, 0x45, 0x33, 0x32, 0x42, 0x37, + 0x46, 0x30, 0x41, 0x41, 0x42, 0x41, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x35, + 0x31, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, + 0x39, 0x45, 0x36, 0x37, 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x39, 0x35, 0x39, 0x45, 0x38, 0x32, 0x34, 0x45, 0x34, + 0x30, 0x45, 0x33, 0x41, 0x32, 0x39, 0x41, 0x41, 0x35, 0x33, 0x39, 0x43, + 0x31, 0x34, 0x46, 0x34, 0x30, 0x34, 0x43, 0x39, 0x43, 0x38, 0x34, 0x32, + 0x35, 0x37, 0x39, 0x43, 0x42, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x35, 0x31, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x45, 0x31, 0x36, + 0x39, 0x31, 0x43, 0x46, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x43, 0x42, 0x39, 0x35, 0x33, 0x39, 0x45, 0x34, 0x34, 0x34, 0x30, + 0x34, 0x31, 0x45, 0x31, 0x41, 0x45, 0x35, 0x39, 0x45, 0x38, 0x35, 0x35, + 0x34, 0x30, 0x34, 0x30, 0x39, 0x43, 0x34, 0x35, 0x33, 0x42, 0x39, 0x33, + 0x35, 0x37, 0x32, 0x31, 0x32, 0x44, 0x34, 0x30, 0x0a, 0x35, 0x31, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x37, 0x42, + 0x34, 0x43, 0x45, 0x46, 0x32, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x43, 0x39, 0x37, 0x33, 0x30, 0x43, 0x30, 0x34, 0x44, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x41, 0x30, 0x46, 0x44, 0x45, 0x32, 0x34, 0x35, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x43, 0x35, 0x33, + 0x41, 0x36, 0x42, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x38, 0x42, 0x38, 0x41, 0x39, 0x38, 0x43, 0x34, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x34, 0x36, 0x42, 0x43, 0x39, 0x30, 0x46, 0x35, + 0x34, 0x34, 0x30, 0x0a, 0x35, 0x31, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x46, 0x38, 0x45, 0x33, 0x37, 0x45, 0x34, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x35, 0x35, 0x44, 0x32, + 0x46, 0x42, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, + 0x39, 0x44, 0x36, 0x41, 0x44, 0x38, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x34, 0x46, 0x39, 0x45, 0x41, 0x35, 0x34, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x32, 0x34, 0x30, 0x31, 0x32, + 0x41, 0x32, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, + 0x43, 0x33, 0x34, 0x38, 0x31, 0x32, 0x32, 0x43, 0x34, 0x30, 0x0a, 0x35, + 0x31, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, + 0x46, 0x34, 0x36, 0x45, 0x33, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x45, 0x42, 0x45, 0x35, 0x41, 0x32, 0x34, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x32, 0x42, 0x39, 0x37, 0x35, + 0x42, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x35, 0x43, 0x31, 0x33, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x45, 0x30, 0x41, 0x41, 0x38, 0x33, 0x44, 0x35, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x32, 0x30, 0x38, 0x35, 0x36, + 0x36, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x31, + 0x30, 0x31, 0x34, 0x36, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x36, 0x41, 0x38, 0x42, 0x42, 0x35, 0x30, 0x30, 0x34, + 0x30, 0x0a, 0x35, 0x31, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x32, 0x34, 0x35, 0x36, 0x30, 0x43, 0x39, 0x35, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x31, 0x33, 0x31, 0x36, 0x30, 0x32, + 0x35, 0x30, 0x34, 0x30, 0x45, 0x41, 0x30, 0x35, 0x45, 0x34, 0x38, 0x31, + 0x37, 0x30, 0x41, 0x44, 0x35, 0x34, 0x34, 0x30, 0x42, 0x30, 0x42, 0x37, + 0x37, 0x37, 0x39, 0x43, 0x38, 0x32, 0x46, 0x32, 0x34, 0x41, 0x34, 0x30, + 0x0a, 0x35, 0x31, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x33, 0x36, 0x46, 0x32, 0x43, 0x39, 0x31, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x38, 0x41, 0x36, 0x31, 0x43, 0x37, 0x44, 0x33, + 0x36, 0x34, 0x30, 0x33, 0x35, 0x31, 0x39, 0x36, 0x42, 0x41, 0x45, 0x35, + 0x32, 0x31, 0x42, 0x33, 0x30, 0x34, 0x30, 0x42, 0x35, 0x37, 0x39, 0x45, + 0x33, 0x34, 0x36, 0x33, 0x39, 0x42, 0x30, 0x34, 0x33, 0x34, 0x30, 0x0a, + 0x35, 0x31, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, + 0x43, 0x46, 0x33, 0x34, 0x46, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x45, 0x43, 0x31, 0x42, 0x36, 0x39, 0x36, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x39, 0x41, 0x33, 0x39, + 0x45, 0x37, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x32, 0x39, 0x32, 0x41, 0x37, 0x37, 0x34, 0x42, 0x34, 0x30, 0x34, 0x45, + 0x31, 0x31, 0x36, 0x44, 0x36, 0x42, 0x38, 0x36, 0x39, 0x30, 0x33, 0x44, + 0x34, 0x30, 0x44, 0x43, 0x44, 0x42, 0x42, 0x46, 0x46, 0x46, 0x42, 0x44, + 0x36, 0x35, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x35, 0x31, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x30, 0x31, 0x43, 0x45, 0x41, + 0x44, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x41, + 0x31, 0x34, 0x38, 0x42, 0x33, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x45, 0x33, 0x45, 0x45, 0x41, 0x30, 0x34, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x46, 0x46, 0x34, 0x34, 0x46, + 0x38, 0x35, 0x38, 0x34, 0x30, 0x43, 0x35, 0x43, 0x37, 0x35, 0x45, 0x30, + 0x45, 0x46, 0x45, 0x43, 0x45, 0x34, 0x32, 0x34, 0x30, 0x43, 0x33, 0x43, + 0x44, 0x30, 0x34, 0x44, 0x31, 0x42, 0x41, 0x30, 0x41, 0x34, 0x42, 0x34, + 0x30, 0x0a, 0x35, 0x32, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x38, 0x34, 0x46, 0x31, 0x46, 0x41, 0x42, 0x33, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x36, 0x33, 0x30, 0x46, 0x44, 0x36, + 0x32, 0x31, 0x34, 0x30, 0x33, 0x43, 0x33, 0x35, 0x45, 0x45, 0x37, 0x34, + 0x32, 0x32, 0x44, 0x38, 0x34, 0x42, 0x34, 0x30, 0x37, 0x30, 0x38, 0x38, + 0x44, 0x31, 0x43, 0x43, 0x39, 0x39, 0x35, 0x42, 0x34, 0x39, 0x34, 0x30, + 0x0a, 0x35, 0x32, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x30, 0x37, 0x37, 0x33, 0x31, 0x43, 0x34, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x38, 0x37, 0x45, 0x37, 0x39, 0x33, 0x38, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x31, 0x37, 0x36, + 0x38, 0x32, 0x35, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x32, 0x32, 0x34, 0x46, 0x33, 0x44, 0x34, 0x35, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x34, 0x35, 0x33, 0x42, 0x39, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x35, 0x45, 0x43, + 0x43, 0x43, 0x31, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x32, 0x34, 0x41, 0x36, 0x33, 0x36, 0x34, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x35, 0x44, 0x38, 0x37, 0x35, 0x35, + 0x32, 0x34, 0x30, 0x0a, 0x35, 0x32, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x38, 0x43, 0x43, 0x34, 0x34, 0x43, 0x37, 0x34, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x34, 0x46, 0x41, 0x41, 0x41, + 0x37, 0x39, 0x34, 0x31, 0x34, 0x30, 0x46, 0x33, 0x37, 0x41, 0x43, 0x31, + 0x41, 0x42, 0x34, 0x37, 0x35, 0x43, 0x34, 0x42, 0x34, 0x30, 0x31, 0x33, + 0x30, 0x46, 0x46, 0x46, 0x36, 0x33, 0x42, 0x30, 0x42, 0x44, 0x34, 0x31, + 0x34, 0x30, 0x0a, 0x35, 0x32, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x41, 0x32, 0x38, 0x44, 0x38, 0x35, 0x33, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x33, 0x33, 0x33, 0x31, 0x45, + 0x42, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x36, + 0x33, 0x32, 0x34, 0x41, 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x34, 0x37, 0x35, 0x39, 0x44, 0x31, 0x46, 0x35, 0x38, 0x34, + 0x30, 0x0a, 0x35, 0x32, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x38, 0x41, 0x30, 0x37, 0x37, 0x43, 0x31, 0x33, 0x45, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x36, 0x39, 0x42, 0x34, 0x37, 0x37, + 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x45, 0x35, 0x39, + 0x33, 0x42, 0x39, 0x35, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x30, 0x33, 0x31, 0x34, 0x34, 0x31, 0x35, 0x33, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x32, 0x36, 0x42, 0x36, 0x44, 0x34, + 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x31, + 0x38, 0x36, 0x44, 0x38, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x31, 0x45, 0x41, 0x34, 0x41, 0x30, 0x35, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x45, 0x41, 0x35, 0x42, 0x42, 0x30, + 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x42, 0x37, + 0x44, 0x34, 0x46, 0x45, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x38, 0x31, 0x33, 0x31, 0x41, 0x31, 0x31, 0x33, 0x38, 0x34, 0x30, + 0x0a, 0x35, 0x32, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x36, 0x36, 0x34, 0x39, 0x42, 0x46, 0x35, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x34, 0x33, 0x35, 0x33, 0x35, 0x30, 0x37, 0x34, + 0x46, 0x34, 0x30, 0x31, 0x33, 0x31, 0x34, 0x43, 0x44, 0x35, 0x43, 0x44, + 0x37, 0x35, 0x39, 0x35, 0x32, 0x34, 0x30, 0x44, 0x41, 0x45, 0x37, 0x44, + 0x44, 0x42, 0x33, 0x39, 0x39, 0x39, 0x44, 0x35, 0x31, 0x34, 0x30, 0x0a, + 0x35, 0x32, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x38, 0x41, 0x32, 0x38, 0x43, 0x36, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x32, 0x37, 0x31, 0x34, 0x35, 0x45, 0x33, 0x39, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x31, 0x44, + 0x44, 0x37, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x36, + 0x43, 0x36, 0x34, 0x37, 0x32, 0x41, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x30, 0x32, 0x41, 0x44, 0x33, 0x42, 0x35, 0x31, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x30, 0x45, 0x35, 0x42, + 0x45, 0x36, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x35, 0x32, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x35, 0x35, 0x35, + 0x46, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x30, + 0x42, 0x45, 0x33, 0x39, 0x31, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x30, 0x31, 0x32, 0x43, 0x41, 0x37, 0x43, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x42, 0x42, 0x41, 0x39, 0x30, + 0x44, 0x34, 0x38, 0x34, 0x30, 0x35, 0x42, 0x41, 0x41, 0x33, 0x36, 0x36, + 0x42, 0x35, 0x39, 0x42, 0x45, 0x35, 0x32, 0x34, 0x30, 0x42, 0x39, 0x31, + 0x37, 0x34, 0x41, 0x31, 0x35, 0x46, 0x45, 0x41, 0x42, 0x34, 0x39, 0x34, + 0x30, 0x0a, 0x35, 0x32, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x30, 0x43, 0x32, 0x30, 0x35, 0x41, 0x37, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x38, 0x38, 0x38, 0x44, 0x33, 0x42, + 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x45, + 0x37, 0x43, 0x43, 0x38, 0x46, 0x38, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x34, 0x42, 0x41, 0x34, 0x30, 0x35, 0x35, 0x34, 0x43, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x41, 0x36, 0x31, 0x44, 0x35, 0x37, 0x32, + 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x38, 0x46, + 0x46, 0x38, 0x36, 0x36, 0x35, 0x36, 0x34, 0x30, 0x0a, 0x35, 0x32, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x32, 0x46, 0x38, 0x41, + 0x35, 0x46, 0x44, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x45, 0x34, 0x45, 0x43, 0x43, 0x42, 0x33, 0x35, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x43, 0x45, 0x44, 0x37, 0x38, 0x46, 0x39, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x41, 0x36, 0x32, 0x45, + 0x42, 0x35, 0x33, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x36, 0x33, 0x31, 0x46, 0x34, 0x33, 0x46, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x43, 0x36, 0x37, 0x36, 0x39, 0x36, 0x34, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x39, 0x45, 0x46, + 0x45, 0x44, 0x42, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x36, 0x33, 0x42, 0x37, 0x39, 0x39, 0x37, 0x35, 0x37, 0x34, 0x30, 0x0a, + 0x35, 0x33, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, + 0x36, 0x45, 0x34, 0x37, 0x36, 0x31, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x41, 0x30, 0x39, 0x42, 0x42, 0x35, 0x46, 0x30, + 0x33, 0x46, 0x35, 0x46, 0x43, 0x41, 0x32, 0x43, 0x44, 0x41, 0x46, 0x36, + 0x32, 0x38, 0x32, 0x32, 0x34, 0x30, 0x37, 0x34, 0x38, 0x31, 0x43, 0x31, + 0x34, 0x44, 0x43, 0x39, 0x34, 0x46, 0x34, 0x30, 0x34, 0x30, 0x0a, 0x35, + 0x33, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x35, + 0x37, 0x38, 0x32, 0x42, 0x36, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x36, 0x30, 0x39, 0x35, 0x38, 0x34, 0x46, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x30, 0x38, 0x43, 0x32, 0x44, + 0x45, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x34, + 0x38, 0x34, 0x45, 0x42, 0x36, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x43, 0x43, 0x35, 0x44, 0x46, 0x36, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x43, 0x38, 0x32, 0x37, 0x30, + 0x44, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x32, + 0x46, 0x39, 0x32, 0x37, 0x43, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x41, 0x35, 0x46, 0x38, 0x38, 0x33, 0x33, 0x38, 0x34, + 0x30, 0x0a, 0x35, 0x33, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x34, 0x34, 0x45, 0x38, 0x33, 0x34, 0x41, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x39, 0x39, 0x39, 0x32, 0x46, 0x36, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x33, 0x46, + 0x30, 0x46, 0x37, 0x37, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x44, 0x35, 0x33, 0x37, 0x36, 0x34, 0x33, 0x39, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x45, 0x39, 0x30, 0x38, 0x44, 0x33, + 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x34, 0x33, + 0x46, 0x35, 0x39, 0x35, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x35, 0x33, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x36, 0x41, + 0x45, 0x36, 0x34, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x32, 0x34, 0x39, 0x46, 0x41, 0x30, 0x31, 0x35, 0x35, 0x34, 0x30, 0x33, + 0x32, 0x32, 0x33, 0x33, 0x39, 0x30, 0x38, 0x41, 0x30, 0x34, 0x35, 0x34, + 0x43, 0x34, 0x30, 0x31, 0x37, 0x46, 0x42, 0x45, 0x42, 0x30, 0x41, 0x34, + 0x41, 0x45, 0x30, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x35, 0x33, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x33, 0x44, 0x38, 0x33, + 0x35, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, + 0x34, 0x30, 0x36, 0x42, 0x34, 0x39, 0x34, 0x34, 0x34, 0x30, 0x39, 0x45, + 0x42, 0x35, 0x31, 0x44, 0x37, 0x36, 0x37, 0x38, 0x37, 0x37, 0x34, 0x35, + 0x34, 0x30, 0x38, 0x41, 0x46, 0x36, 0x32, 0x42, 0x41, 0x35, 0x32, 0x30, + 0x45, 0x41, 0x34, 0x42, 0x34, 0x30, 0x0a, 0x35, 0x33, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x36, 0x44, 0x37, 0x42, 0x37, + 0x34, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, + 0x43, 0x38, 0x44, 0x30, 0x34, 0x32, 0x35, 0x34, 0x30, 0x46, 0x45, 0x42, + 0x31, 0x44, 0x46, 0x41, 0x36, 0x44, 0x42, 0x32, 0x45, 0x35, 0x30, 0x34, + 0x30, 0x35, 0x43, 0x39, 0x43, 0x39, 0x36, 0x35, 0x45, 0x31, 0x41, 0x43, + 0x42, 0x33, 0x41, 0x34, 0x30, 0x0a, 0x35, 0x33, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x32, 0x39, 0x30, 0x44, 0x33, + 0x32, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x34, 0x45, + 0x39, 0x32, 0x30, 0x43, 0x34, 0x32, 0x34, 0x30, 0x32, 0x35, 0x36, 0x38, + 0x39, 0x31, 0x35, 0x46, 0x36, 0x30, 0x39, 0x36, 0x33, 0x43, 0x34, 0x30, + 0x33, 0x34, 0x46, 0x34, 0x34, 0x34, 0x33, 0x41, 0x38, 0x42, 0x38, 0x30, + 0x34, 0x46, 0x34, 0x30, 0x0a, 0x35, 0x33, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x38, 0x30, 0x41, 0x32, 0x32, 0x42, 0x32, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x35, 0x35, 0x34, + 0x38, 0x31, 0x46, 0x34, 0x41, 0x34, 0x30, 0x37, 0x38, 0x35, 0x45, 0x38, + 0x35, 0x33, 0x42, 0x36, 0x30, 0x38, 0x43, 0x32, 0x45, 0x34, 0x30, 0x42, + 0x45, 0x43, 0x39, 0x43, 0x33, 0x44, 0x33, 0x35, 0x36, 0x32, 0x45, 0x34, + 0x45, 0x34, 0x30, 0x0a, 0x35, 0x33, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x34, 0x44, 0x35, 0x36, 0x46, 0x44, 0x37, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x39, 0x44, 0x36, + 0x34, 0x33, 0x35, 0x32, 0x34, 0x30, 0x45, 0x42, 0x41, 0x37, 0x33, 0x31, + 0x37, 0x39, 0x46, 0x31, 0x32, 0x36, 0x35, 0x31, 0x34, 0x30, 0x33, 0x42, + 0x31, 0x34, 0x45, 0x33, 0x33, 0x39, 0x41, 0x42, 0x45, 0x34, 0x35, 0x33, + 0x34, 0x30, 0x0a, 0x35, 0x33, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x45, 0x41, 0x46, 0x38, 0x36, 0x44, 0x45, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x45, 0x31, 0x35, 0x34, 0x43, 0x31, + 0x32, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, + 0x38, 0x39, 0x30, 0x42, 0x30, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x34, 0x46, 0x46, 0x46, 0x41, 0x45, 0x33, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x38, 0x30, 0x45, 0x30, 0x34, + 0x33, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x32, + 0x42, 0x37, 0x30, 0x39, 0x42, 0x34, 0x39, 0x34, 0x30, 0x42, 0x45, 0x33, + 0x42, 0x31, 0x32, 0x41, 0x32, 0x41, 0x45, 0x34, 0x34, 0x34, 0x36, 0x34, + 0x30, 0x43, 0x35, 0x46, 0x39, 0x46, 0x46, 0x33, 0x31, 0x36, 0x41, 0x38, + 0x34, 0x34, 0x34, 0x34, 0x30, 0x0a, 0x35, 0x34, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x32, 0x43, 0x34, 0x32, 0x35, 0x45, 0x42, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x41, 0x32, 0x32, + 0x45, 0x30, 0x42, 0x45, 0x35, 0x30, 0x34, 0x30, 0x36, 0x35, 0x37, 0x31, + 0x44, 0x38, 0x42, 0x46, 0x41, 0x42, 0x36, 0x43, 0x35, 0x35, 0x34, 0x30, + 0x46, 0x30, 0x38, 0x30, 0x43, 0x32, 0x33, 0x35, 0x43, 0x38, 0x44, 0x33, + 0x35, 0x30, 0x34, 0x30, 0x0a, 0x35, 0x34, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x38, 0x38, 0x43, 0x32, 0x33, 0x34, 0x42, 0x33, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x31, 0x43, + 0x31, 0x43, 0x42, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x45, 0x45, 0x39, 0x39, 0x34, 0x33, 0x31, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x44, 0x32, 0x45, 0x42, 0x36, 0x43, 0x34, + 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x43, 0x37, + 0x39, 0x41, 0x45, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x30, 0x44, 0x39, 0x42, 0x36, 0x35, 0x38, 0x32, 0x45, 0x34, 0x30, 0x0a, + 0x35, 0x34, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x43, 0x35, 0x39, 0x32, 0x31, 0x36, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x42, 0x38, 0x38, 0x32, 0x35, 0x46, 0x38, 0x34, 0x34, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x36, 0x36, 0x33, 0x31, + 0x34, 0x30, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, + 0x34, 0x36, 0x46, 0x37, 0x46, 0x35, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x32, 0x37, 0x44, 0x42, 0x38, 0x39, 0x30, 0x35, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, 0x34, + 0x45, 0x46, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x35, 0x34, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x43, 0x33, 0x45, 0x44, 0x45, + 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, + 0x46, 0x44, 0x34, 0x45, 0x45, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x30, 0x32, 0x35, 0x39, 0x43, 0x35, 0x32, 0x32, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x45, 0x35, 0x43, 0x44, 0x41, + 0x36, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x35, 0x34, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x38, 0x42, 0x36, 0x34, 0x32, + 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x46, 0x41, + 0x42, 0x37, 0x44, 0x38, 0x32, 0x42, 0x34, 0x30, 0x31, 0x33, 0x43, 0x36, + 0x31, 0x42, 0x34, 0x45, 0x38, 0x32, 0x33, 0x41, 0x34, 0x45, 0x34, 0x30, + 0x42, 0x39, 0x42, 0x34, 0x31, 0x45, 0x33, 0x44, 0x37, 0x30, 0x46, 0x32, + 0x32, 0x38, 0x34, 0x30, 0x0a, 0x35, 0x34, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x34, 0x34, 0x35, 0x34, 0x42, 0x45, 0x43, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x38, + 0x34, 0x38, 0x38, 0x44, 0x30, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x36, 0x38, 0x36, 0x46, 0x44, 0x44, 0x34, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x44, 0x46, 0x36, 0x35, 0x43, 0x34, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x41, 0x42, + 0x39, 0x35, 0x30, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x34, 0x35, 0x32, 0x46, 0x32, 0x39, 0x46, 0x34, 0x34, 0x34, 0x30, 0x45, + 0x36, 0x35, 0x35, 0x45, 0x46, 0x38, 0x43, 0x32, 0x38, 0x36, 0x38, 0x34, + 0x33, 0x34, 0x30, 0x42, 0x46, 0x38, 0x39, 0x34, 0x45, 0x43, 0x43, 0x45, + 0x43, 0x36, 0x46, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x35, 0x34, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x46, 0x30, 0x35, + 0x44, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, + 0x33, 0x33, 0x44, 0x37, 0x43, 0x39, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x32, 0x37, 0x32, 0x39, 0x37, 0x36, 0x31, 0x32, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x38, 0x37, 0x38, 0x41, + 0x45, 0x37, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x42, 0x39, 0x32, 0x37, 0x39, 0x32, 0x33, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x42, 0x34, 0x42, 0x36, 0x36, 0x30, 0x35, 0x30, + 0x34, 0x30, 0x0a, 0x35, 0x34, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x45, 0x35, 0x43, 0x44, 0x44, 0x32, 0x34, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x32, 0x34, 0x30, 0x36, 0x45, + 0x37, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x35, + 0x43, 0x33, 0x32, 0x30, 0x39, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x43, 0x43, 0x31, 0x37, 0x33, 0x34, 0x39, 0x34, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x41, 0x37, 0x44, 0x42, 0x36, + 0x33, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x43, + 0x45, 0x39, 0x31, 0x43, 0x33, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x43, 0x41, 0x38, 0x34, 0x36, 0x41, 0x34, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x42, 0x33, 0x44, 0x36, 0x30, + 0x44, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x37, + 0x41, 0x35, 0x46, 0x31, 0x46, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x30, 0x31, 0x43, 0x35, 0x35, 0x46, 0x31, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x33, 0x45, 0x34, 0x35, + 0x36, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x46, + 0x45, 0x39, 0x32, 0x44, 0x45, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x35, 0x34, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x42, 0x31, + 0x32, 0x44, 0x31, 0x38, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x30, 0x31, 0x39, 0x44, 0x31, 0x31, 0x36, 0x33, 0x32, 0x34, 0x30, + 0x45, 0x43, 0x46, 0x45, 0x41, 0x44, 0x36, 0x30, 0x39, 0x30, 0x37, 0x38, + 0x34, 0x33, 0x34, 0x30, 0x41, 0x36, 0x34, 0x33, 0x35, 0x46, 0x42, 0x39, + 0x45, 0x31, 0x31, 0x34, 0x33, 0x42, 0x34, 0x30, 0x0a, 0x35, 0x34, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x35, 0x36, 0x43, + 0x42, 0x30, 0x33, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x34, 0x35, 0x34, 0x35, 0x39, 0x43, 0x41, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x43, 0x42, 0x43, 0x45, 0x30, 0x36, 0x45, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x45, 0x30, 0x43, + 0x39, 0x42, 0x34, 0x31, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x43, 0x44, 0x42, 0x38, 0x37, 0x42, 0x34, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x33, 0x43, 0x46, 0x39, 0x42, 0x32, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x46, 0x44, 0x30, + 0x43, 0x32, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x32, 0x33, 0x41, 0x43, 0x41, 0x36, 0x46, 0x35, 0x33, 0x34, 0x30, 0x0a, + 0x35, 0x35, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x45, 0x34, 0x34, 0x38, 0x34, 0x35, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x41, 0x32, 0x41, 0x43, 0x42, 0x35, 0x32, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x43, 0x35, 0x45, 0x45, + 0x31, 0x44, 0x32, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, + 0x33, 0x34, 0x34, 0x35, 0x43, 0x42, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x45, 0x31, 0x37, 0x39, 0x41, 0x43, 0x44, 0x35, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x42, 0x42, 0x38, 0x36, + 0x31, 0x32, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, + 0x30, 0x31, 0x46, 0x46, 0x32, 0x31, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x39, 0x36, 0x34, 0x45, 0x33, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x37, 0x37, 0x31, 0x34, + 0x41, 0x30, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x41, 0x31, 0x43, 0x33, 0x31, 0x42, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x35, + 0x35, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x32, + 0x32, 0x35, 0x31, 0x37, 0x37, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x41, 0x38, 0x31, 0x43, 0x31, 0x35, 0x35, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x37, 0x44, 0x43, 0x33, 0x39, + 0x44, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x36, + 0x34, 0x41, 0x34, 0x42, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x45, 0x43, 0x41, 0x43, 0x32, 0x42, 0x32, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x35, 0x44, 0x38, 0x46, 0x46, + 0x33, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x35, 0x35, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, 0x31, 0x43, 0x35, 0x44, 0x32, + 0x31, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x43, 0x36, 0x42, + 0x32, 0x33, 0x39, 0x37, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x30, 0x37, 0x42, 0x44, 0x33, 0x42, 0x30, 0x33, 0x46, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x39, 0x31, 0x35, 0x30, 0x35, 0x31, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x32, 0x44, + 0x31, 0x32, 0x33, 0x32, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x43, 0x33, 0x33, 0x38, 0x45, 0x43, 0x45, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x31, 0x33, 0x32, 0x34, 0x35, 0x45, + 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x36, 0x39, + 0x41, 0x42, 0x30, 0x38, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x34, 0x44, 0x35, 0x31, 0x38, 0x34, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x42, 0x44, 0x30, 0x42, 0x32, 0x43, + 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x34, + 0x35, 0x43, 0x39, 0x34, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x41, 0x34, 0x41, 0x36, 0x45, 0x31, 0x32, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x34, 0x44, 0x36, 0x31, 0x45, 0x46, + 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x31, 0x38, + 0x41, 0x35, 0x44, 0x39, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x35, 0x35, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x32, 0x36, 0x31, + 0x46, 0x37, 0x33, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x45, 0x34, 0x43, 0x45, 0x41, 0x41, 0x34, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x32, 0x32, 0x34, 0x30, 0x34, 0x32, + 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x43, 0x46, 0x44, 0x36, + 0x46, 0x44, 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x33, 0x34, 0x41, 0x37, 0x44, 0x37, 0x33, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x38, 0x35, 0x34, 0x41, 0x38, 0x34, + 0x32, 0x34, 0x30, 0x0a, 0x35, 0x35, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x32, 0x39, 0x44, 0x43, 0x42, 0x43, 0x33, 0x35, 0x34, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x43, 0x34, 0x41, 0x41, + 0x34, 0x45, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, + 0x35, 0x41, 0x33, 0x42, 0x46, 0x32, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x38, 0x33, 0x46, 0x31, 0x41, 0x33, 0x33, 0x34, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x38, 0x34, 0x44, 0x43, + 0x44, 0x38, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x45, 0x46, 0x46, 0x42, 0x32, 0x44, 0x30, 0x41, 0x34, 0x30, 0x0a, 0x35, + 0x35, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x44, + 0x30, 0x46, 0x45, 0x45, 0x46, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x30, 0x31, 0x45, 0x30, 0x32, 0x36, 0x43, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x30, 0x45, 0x32, 0x46, 0x42, + 0x43, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x41, 0x33, + 0x42, 0x32, 0x32, 0x38, 0x37, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x38, 0x46, 0x44, 0x33, 0x36, 0x37, 0x30, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x32, 0x37, 0x35, 0x34, + 0x44, 0x31, 0x36, 0x34, 0x30, 0x42, 0x41, 0x41, 0x37, 0x38, 0x33, 0x42, + 0x37, 0x38, 0x38, 0x36, 0x36, 0x35, 0x30, 0x34, 0x30, 0x43, 0x36, 0x39, + 0x41, 0x34, 0x33, 0x39, 0x32, 0x30, 0x33, 0x39, 0x30, 0x32, 0x45, 0x34, + 0x30, 0x0a, 0x35, 0x35, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x30, 0x41, 0x38, 0x30, 0x34, 0x32, 0x35, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, 0x39, 0x45, 0x37, 0x34, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x46, 0x45, + 0x31, 0x44, 0x34, 0x46, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x38, 0x38, 0x32, 0x42, 0x32, 0x44, 0x44, 0x33, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x31, 0x41, 0x37, 0x46, 0x35, + 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, 0x41, + 0x33, 0x42, 0x46, 0x35, 0x31, 0x33, 0x34, 0x30, 0x0a, 0x35, 0x35, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x38, 0x43, 0x46, + 0x44, 0x43, 0x45, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x36, 0x36, 0x32, 0x33, 0x46, 0x33, 0x33, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x38, 0x32, 0x46, 0x38, 0x38, 0x43, 0x34, 0x33, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x44, 0x45, 0x41, + 0x35, 0x45, 0x43, 0x34, 0x35, 0x34, 0x30, 0x36, 0x33, 0x45, 0x42, 0x31, + 0x45, 0x42, 0x34, 0x43, 0x32, 0x31, 0x32, 0x34, 0x39, 0x34, 0x30, 0x36, + 0x45, 0x38, 0x36, 0x44, 0x30, 0x42, 0x41, 0x42, 0x42, 0x45, 0x39, 0x34, + 0x43, 0x34, 0x30, 0x0a, 0x35, 0x35, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x44, 0x41, 0x38, 0x33, 0x39, 0x37, 0x33, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x37, 0x32, 0x41, 0x43, + 0x38, 0x45, 0x33, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, + 0x30, 0x35, 0x31, 0x46, 0x34, 0x37, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x33, 0x37, 0x45, 0x31, 0x32, 0x41, 0x33, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, 0x44, 0x46, 0x41, 0x43, + 0x30, 0x37, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x33, 0x42, 0x34, 0x42, 0x32, 0x35, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x43, 0x35, 0x33, 0x33, 0x31, 0x30, 0x45, 0x34, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x44, 0x45, 0x35, 0x44, + 0x41, 0x31, 0x33, 0x30, 0x34, 0x30, 0x45, 0x39, 0x37, 0x39, 0x31, 0x41, + 0x39, 0x41, 0x36, 0x34, 0x35, 0x32, 0x34, 0x31, 0x34, 0x30, 0x43, 0x34, + 0x35, 0x36, 0x46, 0x35, 0x34, 0x42, 0x42, 0x33, 0x36, 0x33, 0x34, 0x32, + 0x34, 0x30, 0x0a, 0x35, 0x35, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x30, 0x33, 0x41, 0x39, 0x31, 0x42, 0x43, 0x33, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x35, 0x31, 0x34, 0x37, 0x35, + 0x36, 0x34, 0x45, 0x34, 0x30, 0x42, 0x35, 0x34, 0x34, 0x46, 0x45, 0x35, + 0x32, 0x41, 0x46, 0x37, 0x44, 0x33, 0x43, 0x34, 0x30, 0x44, 0x38, 0x44, + 0x37, 0x46, 0x44, 0x31, 0x39, 0x38, 0x30, 0x42, 0x44, 0x34, 0x44, 0x34, + 0x30, 0x0a, 0x35, 0x36, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x38, 0x36, 0x44, 0x46, 0x41, 0x46, 0x42, 0x34, 0x42, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x33, 0x39, 0x44, 0x45, 0x37, 0x30, + 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, + 0x35, 0x38, 0x44, 0x36, 0x44, 0x42, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x34, 0x32, 0x44, 0x44, 0x45, 0x32, 0x33, 0x35, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x33, 0x39, 0x31, 0x41, 0x39, 0x43, + 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x42, 0x36, + 0x43, 0x42, 0x37, 0x45, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x38, 0x37, 0x42, 0x39, 0x36, 0x41, 0x45, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x34, 0x36, 0x38, 0x35, 0x46, 0x46, + 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x31, 0x45, + 0x37, 0x35, 0x34, 0x33, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x43, 0x34, 0x41, 0x35, 0x45, 0x36, 0x42, 0x34, 0x33, 0x34, 0x30, + 0x0a, 0x35, 0x36, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x43, 0x31, 0x42, 0x37, 0x45, 0x39, 0x45, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x38, 0x33, 0x36, 0x35, 0x36, 0x38, 0x38, 0x34, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x41, 0x35, 0x45, + 0x36, 0x34, 0x42, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x41, 0x32, 0x43, 0x32, 0x38, 0x43, 0x34, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x44, 0x37, 0x39, 0x32, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x42, 0x39, 0x36, + 0x37, 0x33, 0x41, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x38, 0x34, 0x42, 0x38, 0x31, 0x43, 0x44, 0x33, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x43, 0x46, 0x38, 0x38, 0x46, 0x33, 0x38, 0x35, + 0x35, 0x34, 0x30, 0x0a, 0x35, 0x36, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x38, 0x30, 0x38, 0x42, 0x30, 0x37, 0x35, 0x33, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x36, 0x32, 0x30, + 0x39, 0x43, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, + 0x37, 0x34, 0x34, 0x36, 0x38, 0x33, 0x33, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x30, 0x46, 0x33, 0x41, 0x39, 0x42, 0x33, 0x32, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x45, 0x42, 0x34, 0x38, + 0x39, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x34, + 0x37, 0x46, 0x44, 0x42, 0x35, 0x34, 0x34, 0x41, 0x34, 0x30, 0x0a, 0x35, + 0x36, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, + 0x33, 0x43, 0x31, 0x43, 0x44, 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x34, 0x31, 0x43, 0x37, 0x32, 0x37, 0x44, 0x34, 0x46, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x34, 0x43, 0x36, 0x46, 0x43, + 0x33, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x32, + 0x43, 0x45, 0x45, 0x31, 0x42, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x38, 0x31, 0x33, 0x44, 0x39, 0x46, 0x32, 0x33, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, 0x43, 0x32, 0x32, 0x36, 0x31, + 0x41, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x38, + 0x34, 0x43, 0x34, 0x33, 0x37, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x41, 0x37, 0x32, 0x39, 0x34, 0x45, 0x30, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x46, 0x37, 0x38, 0x31, 0x36, + 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, + 0x33, 0x41, 0x36, 0x37, 0x32, 0x31, 0x37, 0x34, 0x30, 0x0a, 0x35, 0x36, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x34, 0x39, + 0x36, 0x33, 0x41, 0x43, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x34, 0x44, 0x45, 0x43, 0x39, 0x33, 0x31, 0x34, 0x38, 0x34, 0x30, + 0x43, 0x38, 0x32, 0x32, 0x39, 0x39, 0x39, 0x37, 0x39, 0x43, 0x46, 0x37, + 0x34, 0x38, 0x34, 0x30, 0x42, 0x30, 0x46, 0x31, 0x42, 0x43, 0x44, 0x33, + 0x30, 0x39, 0x33, 0x38, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x35, 0x36, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x36, 0x43, 0x33, + 0x38, 0x38, 0x41, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x42, 0x34, 0x38, 0x32, 0x37, 0x31, 0x34, 0x39, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x36, 0x32, 0x37, 0x35, 0x46, 0x35, 0x39, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x33, 0x38, 0x38, + 0x34, 0x36, 0x46, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x34, 0x31, 0x44, 0x33, 0x42, 0x42, 0x32, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x36, 0x41, 0x42, 0x36, 0x44, 0x38, 0x32, + 0x31, 0x34, 0x30, 0x0a, 0x35, 0x36, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x35, 0x39, 0x36, 0x31, 0x36, 0x38, 0x34, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, 0x39, 0x30, 0x33, 0x44, + 0x35, 0x35, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, + 0x43, 0x44, 0x37, 0x34, 0x38, 0x42, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x37, 0x44, 0x31, 0x34, 0x35, 0x33, 0x33, 0x38, + 0x34, 0x30, 0x0a, 0x35, 0x36, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x36, 0x32, 0x44, 0x39, 0x46, 0x30, 0x32, 0x35, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x36, 0x37, 0x38, 0x30, 0x31, + 0x46, 0x32, 0x35, 0x34, 0x30, 0x45, 0x44, 0x37, 0x30, 0x36, 0x44, 0x37, + 0x44, 0x37, 0x34, 0x39, 0x42, 0x34, 0x30, 0x34, 0x30, 0x42, 0x32, 0x46, + 0x38, 0x31, 0x37, 0x34, 0x33, 0x35, 0x33, 0x36, 0x30, 0x33, 0x34, 0x34, + 0x30, 0x0a, 0x35, 0x36, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x43, 0x42, 0x30, 0x37, 0x37, 0x41, 0x32, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x30, 0x39, 0x39, 0x41, 0x42, 0x35, + 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x33, 0x46, + 0x42, 0x39, 0x38, 0x43, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x34, 0x34, 0x32, 0x37, 0x30, 0x35, 0x33, 0x46, 0x34, 0x30, + 0x36, 0x36, 0x31, 0x44, 0x33, 0x32, 0x35, 0x38, 0x32, 0x30, 0x36, 0x30, + 0x34, 0x44, 0x34, 0x30, 0x32, 0x46, 0x35, 0x32, 0x33, 0x39, 0x31, 0x33, + 0x45, 0x46, 0x39, 0x38, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x35, 0x36, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x44, 0x30, + 0x35, 0x42, 0x39, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x43, 0x35, 0x42, 0x41, 0x34, 0x43, 0x34, 0x34, 0x46, 0x34, 0x30, 0x35, + 0x31, 0x35, 0x31, 0x44, 0x43, 0x45, 0x45, 0x41, 0x41, 0x44, 0x45, 0x34, + 0x31, 0x34, 0x30, 0x31, 0x46, 0x46, 0x45, 0x33, 0x37, 0x42, 0x37, 0x34, + 0x34, 0x31, 0x45, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x35, 0x37, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x43, 0x37, 0x38, 0x43, + 0x46, 0x37, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, + 0x32, 0x43, 0x37, 0x33, 0x44, 0x31, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x34, 0x41, 0x36, 0x31, 0x37, 0x30, 0x46, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x32, 0x37, 0x31, 0x39, 0x43, + 0x30, 0x41, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x33, 0x38, 0x34, 0x44, 0x36, 0x42, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x37, 0x32, 0x41, 0x43, 0x46, 0x30, 0x35, 0x38, + 0x34, 0x30, 0x0a, 0x35, 0x37, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x45, 0x33, 0x30, 0x34, 0x32, 0x46, 0x42, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x36, 0x42, 0x38, 0x45, 0x31, + 0x32, 0x35, 0x37, 0x34, 0x30, 0x41, 0x34, 0x45, 0x31, 0x32, 0x45, 0x31, + 0x30, 0x35, 0x46, 0x44, 0x36, 0x35, 0x33, 0x34, 0x30, 0x45, 0x43, 0x33, + 0x36, 0x39, 0x37, 0x46, 0x41, 0x34, 0x41, 0x30, 0x33, 0x35, 0x34, 0x34, + 0x30, 0x0a, 0x35, 0x37, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x45, 0x34, 0x41, 0x46, 0x34, 0x42, 0x31, 0x35, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x41, 0x35, 0x35, 0x34, 0x34, 0x44, + 0x34, 0x36, 0x34, 0x30, 0x43, 0x43, 0x42, 0x39, 0x43, 0x44, 0x44, 0x44, + 0x33, 0x31, 0x44, 0x33, 0x34, 0x36, 0x34, 0x30, 0x42, 0x30, 0x38, 0x32, + 0x35, 0x38, 0x42, 0x38, 0x30, 0x39, 0x39, 0x46, 0x33, 0x34, 0x34, 0x30, + 0x0a, 0x35, 0x37, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x43, 0x32, 0x42, 0x45, 0x42, 0x45, 0x39, 0x34, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x30, 0x46, 0x42, 0x44, 0x34, 0x35, 0x30, 0x32, + 0x30, 0x34, 0x30, 0x34, 0x42, 0x43, 0x34, 0x30, 0x45, 0x34, 0x42, 0x42, + 0x31, 0x34, 0x31, 0x34, 0x31, 0x34, 0x30, 0x42, 0x36, 0x32, 0x45, 0x41, + 0x41, 0x36, 0x44, 0x43, 0x41, 0x44, 0x30, 0x33, 0x41, 0x34, 0x30, 0x0a, + 0x35, 0x37, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x32, 0x38, 0x45, 0x46, 0x44, 0x44, 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x38, 0x41, 0x30, 0x42, 0x44, 0x35, 0x33, 0x33, 0x30, + 0x34, 0x30, 0x32, 0x39, 0x35, 0x34, 0x41, 0x41, 0x37, 0x32, 0x43, 0x45, + 0x36, 0x44, 0x33, 0x39, 0x34, 0x30, 0x36, 0x38, 0x37, 0x41, 0x37, 0x37, + 0x37, 0x37, 0x44, 0x31, 0x33, 0x44, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x35, + 0x37, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x45, + 0x37, 0x30, 0x33, 0x44, 0x45, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x41, 0x30, 0x39, 0x43, 0x39, 0x37, 0x43, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x45, 0x32, 0x44, 0x32, 0x46, + 0x32, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, + 0x42, 0x37, 0x31, 0x45, 0x32, 0x34, 0x43, 0x34, 0x30, 0x31, 0x30, 0x44, + 0x32, 0x31, 0x46, 0x33, 0x39, 0x39, 0x32, 0x34, 0x35, 0x34, 0x42, 0x34, + 0x30, 0x33, 0x30, 0x42, 0x38, 0x38, 0x36, 0x43, 0x36, 0x32, 0x38, 0x32, + 0x30, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x35, 0x37, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x36, 0x34, 0x36, 0x39, 0x42, 0x43, + 0x32, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x30, 0x38, + 0x42, 0x46, 0x32, 0x37, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x38, 0x36, 0x35, 0x34, 0x41, 0x30, 0x34, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x44, 0x31, 0x32, 0x36, 0x46, 0x46, + 0x34, 0x36, 0x34, 0x30, 0x33, 0x37, 0x36, 0x36, 0x43, 0x35, 0x44, 0x33, + 0x38, 0x33, 0x35, 0x42, 0x34, 0x43, 0x34, 0x30, 0x37, 0x31, 0x31, 0x42, + 0x42, 0x32, 0x34, 0x42, 0x30, 0x32, 0x32, 0x38, 0x34, 0x43, 0x34, 0x30, + 0x0a, 0x35, 0x37, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x38, 0x33, 0x37, 0x38, 0x46, 0x33, 0x30, 0x33, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x38, 0x35, 0x32, 0x30, 0x37, 0x37, 0x35, 0x33, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x43, 0x32, 0x46, + 0x44, 0x41, 0x33, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x38, 0x30, 0x44, 0x42, 0x31, 0x31, 0x31, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x36, 0x36, 0x32, 0x37, 0x41, 0x30, 0x45, 0x35, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x32, 0x44, 0x45, + 0x39, 0x38, 0x45, 0x31, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x33, 0x35, 0x43, 0x31, 0x44, 0x45, 0x30, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x36, 0x39, 0x33, 0x37, 0x41, 0x35, 0x33, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x31, 0x42, + 0x32, 0x33, 0x46, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x41, 0x46, 0x37, 0x39, 0x34, 0x39, 0x37, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x30, 0x39, 0x33, 0x45, 0x35, 0x41, 0x39, 0x34, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x42, 0x39, 0x37, + 0x32, 0x34, 0x33, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x36, 0x39, 0x41, 0x36, 0x42, 0x32, 0x33, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x43, 0x38, 0x33, 0x31, 0x33, 0x37, 0x38, 0x35, + 0x38, 0x34, 0x30, 0x0a, 0x35, 0x37, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x43, 0x30, 0x45, 0x34, 0x34, 0x35, 0x44, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x35, 0x31, 0x33, 0x32, + 0x34, 0x43, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x36, 0x33, 0x32, 0x46, 0x33, 0x46, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x42, 0x31, 0x31, 0x33, 0x34, 0x44, 0x31, 0x46, + 0x34, 0x30, 0x0a, 0x35, 0x37, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x33, 0x45, 0x37, 0x30, 0x44, 0x32, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x43, 0x39, 0x45, + 0x38, 0x34, 0x41, 0x34, 0x30, 0x39, 0x46, 0x43, 0x35, 0x39, 0x44, 0x30, + 0x41, 0x30, 0x37, 0x38, 0x32, 0x34, 0x30, 0x34, 0x30, 0x35, 0x42, 0x39, + 0x36, 0x43, 0x44, 0x33, 0x45, 0x41, 0x39, 0x41, 0x45, 0x35, 0x32, 0x34, + 0x30, 0x0a, 0x35, 0x38, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x34, 0x41, 0x37, 0x32, 0x45, 0x33, 0x45, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x46, 0x43, 0x37, 0x36, 0x43, 0x34, + 0x34, 0x46, 0x34, 0x30, 0x34, 0x39, 0x31, 0x44, 0x31, 0x42, 0x38, 0x35, + 0x46, 0x46, 0x36, 0x33, 0x34, 0x41, 0x34, 0x30, 0x41, 0x43, 0x41, 0x41, + 0x39, 0x41, 0x44, 0x43, 0x39, 0x30, 0x41, 0x43, 0x33, 0x38, 0x34, 0x30, + 0x0a, 0x35, 0x38, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x30, 0x38, 0x37, 0x34, 0x45, 0x33, 0x44, 0x33, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x34, 0x41, 0x37, 0x41, 0x38, 0x32, 0x43, 0x34, + 0x31, 0x34, 0x30, 0x33, 0x38, 0x33, 0x35, 0x38, 0x38, 0x42, 0x45, 0x45, + 0x30, 0x35, 0x43, 0x35, 0x33, 0x34, 0x30, 0x36, 0x33, 0x44, 0x36, 0x30, + 0x39, 0x42, 0x44, 0x33, 0x32, 0x39, 0x38, 0x34, 0x44, 0x34, 0x30, 0x0a, + 0x35, 0x38, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, + 0x36, 0x39, 0x32, 0x35, 0x41, 0x36, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x38, 0x32, 0x38, 0x41, 0x36, 0x30, 0x43, 0x33, 0x42, + 0x34, 0x30, 0x36, 0x30, 0x42, 0x41, 0x34, 0x31, 0x35, 0x41, 0x45, 0x44, + 0x42, 0x37, 0x35, 0x32, 0x34, 0x30, 0x34, 0x39, 0x31, 0x33, 0x36, 0x44, + 0x33, 0x38, 0x30, 0x35, 0x36, 0x30, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x35, + 0x38, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x46, + 0x35, 0x35, 0x31, 0x30, 0x44, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x30, 0x44, 0x44, 0x38, 0x42, 0x43, 0x33, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, 0x31, 0x42, 0x45, 0x33, 0x34, + 0x43, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x45, + 0x45, 0x34, 0x32, 0x34, 0x37, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x30, 0x32, 0x31, 0x38, 0x39, 0x34, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x35, 0x41, 0x32, 0x35, + 0x45, 0x46, 0x30, 0x33, 0x46, 0x0a, 0x35, 0x38, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x39, 0x39, 0x45, 0x34, 0x44, 0x33, + 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x42, 0x45, + 0x39, 0x44, 0x41, 0x46, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x41, 0x46, 0x31, 0x37, 0x44, 0x32, 0x36, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, 0x36, 0x37, 0x31, 0x37, 0x43, 0x35, + 0x34, 0x37, 0x34, 0x30, 0x0a, 0x35, 0x38, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x32, 0x33, 0x31, 0x43, 0x38, 0x41, 0x31, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x34, 0x46, 0x31, + 0x38, 0x38, 0x42, 0x34, 0x37, 0x34, 0x30, 0x35, 0x35, 0x35, 0x37, 0x46, + 0x41, 0x38, 0x39, 0x38, 0x43, 0x42, 0x39, 0x33, 0x34, 0x34, 0x30, 0x35, + 0x37, 0x44, 0x44, 0x31, 0x43, 0x31, 0x38, 0x41, 0x30, 0x31, 0x32, 0x34, + 0x45, 0x34, 0x30, 0x0a, 0x35, 0x38, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x34, 0x46, 0x46, 0x41, 0x42, 0x33, 0x36, 0x34, 0x45, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x45, 0x33, 0x42, 0x36, 0x35, + 0x42, 0x43, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x45, + 0x45, 0x34, 0x45, 0x41, 0x45, 0x42, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x41, 0x39, 0x33, 0x45, 0x35, 0x33, + 0x34, 0x30, 0x0a, 0x35, 0x38, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x45, 0x34, 0x32, 0x43, 0x45, 0x45, 0x33, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x34, 0x31, 0x34, 0x38, 0x31, + 0x35, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x44, + 0x38, 0x33, 0x44, 0x41, 0x45, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x34, 0x35, 0x45, 0x42, 0x31, 0x33, 0x30, 0x35, 0x32, 0x34, + 0x30, 0x0a, 0x35, 0x38, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x36, 0x45, 0x32, 0x30, 0x33, 0x30, 0x35, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x45, 0x39, 0x32, 0x42, 0x37, 0x32, + 0x35, 0x32, 0x34, 0x30, 0x44, 0x36, 0x30, 0x44, 0x42, 0x33, 0x36, 0x30, + 0x31, 0x31, 0x32, 0x45, 0x34, 0x45, 0x34, 0x30, 0x30, 0x46, 0x36, 0x42, + 0x32, 0x38, 0x35, 0x45, 0x35, 0x46, 0x30, 0x33, 0x35, 0x32, 0x34, 0x30, + 0x0a, 0x35, 0x38, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x32, 0x37, 0x45, 0x39, 0x39, 0x30, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x43, 0x44, 0x42, 0x45, 0x42, 0x32, 0x39, 0x34, + 0x31, 0x34, 0x30, 0x37, 0x38, 0x35, 0x35, 0x44, 0x46, 0x44, 0x33, 0x37, + 0x33, 0x35, 0x31, 0x33, 0x36, 0x34, 0x30, 0x35, 0x39, 0x45, 0x35, 0x38, + 0x37, 0x35, 0x36, 0x39, 0x33, 0x44, 0x34, 0x34, 0x46, 0x34, 0x30, 0x0a, + 0x35, 0x39, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x37, 0x31, 0x30, 0x46, 0x31, 0x39, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x34, 0x34, 0x37, 0x44, 0x30, 0x45, 0x42, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x46, 0x43, 0x32, + 0x30, 0x45, 0x32, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, + 0x31, 0x33, 0x44, 0x35, 0x43, 0x39, 0x34, 0x41, 0x34, 0x30, 0x39, 0x42, + 0x37, 0x39, 0x34, 0x34, 0x30, 0x41, 0x39, 0x32, 0x30, 0x46, 0x34, 0x30, + 0x34, 0x30, 0x34, 0x38, 0x33, 0x32, 0x30, 0x35, 0x30, 0x39, 0x38, 0x41, + 0x37, 0x33, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x35, 0x39, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x37, 0x44, 0x42, 0x43, 0x42, + 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x37, 0x36, 0x42, 0x38, 0x34, 0x45, 0x42, 0x33, 0x46, 0x39, 0x44, 0x35, + 0x30, 0x35, 0x38, 0x33, 0x31, 0x37, 0x38, 0x32, 0x32, 0x35, 0x31, 0x34, + 0x30, 0x38, 0x30, 0x33, 0x37, 0x39, 0x33, 0x42, 0x35, 0x42, 0x37, 0x43, + 0x31, 0x33, 0x46, 0x34, 0x30, 0x0a, 0x35, 0x39, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x35, 0x37, 0x36, 0x33, 0x30, 0x36, + 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x46, 0x38, + 0x46, 0x36, 0x39, 0x43, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x43, 0x43, 0x46, 0x31, 0x46, 0x31, 0x38, 0x34, 0x44, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x32, 0x36, 0x31, 0x44, 0x38, 0x38, 0x36, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x41, 0x31, + 0x30, 0x32, 0x41, 0x30, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x30, 0x30, 0x41, 0x37, 0x41, 0x38, 0x39, 0x31, 0x31, 0x34, 0x30, + 0x0a, 0x35, 0x39, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x41, 0x46, 0x39, 0x44, 0x41, 0x45, 0x31, 0x35, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x38, 0x35, 0x34, 0x30, 0x34, 0x46, 0x42, 0x34, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x41, 0x37, 0x32, + 0x42, 0x31, 0x35, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x34, 0x45, 0x39, 0x38, 0x38, 0x32, 0x32, 0x31, 0x34, 0x30, 0x33, + 0x43, 0x33, 0x35, 0x39, 0x36, 0x45, 0x43, 0x30, 0x37, 0x30, 0x42, 0x34, + 0x44, 0x34, 0x30, 0x46, 0x43, 0x42, 0x41, 0x37, 0x41, 0x45, 0x42, 0x41, + 0x32, 0x30, 0x32, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x35, 0x39, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x37, 0x45, 0x43, 0x35, + 0x41, 0x42, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x45, 0x37, 0x36, 0x37, 0x44, 0x43, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x36, 0x46, 0x41, 0x38, 0x33, 0x37, 0x38, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x42, 0x44, 0x41, 0x33, + 0x33, 0x39, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, + 0x36, 0x45, 0x43, 0x36, 0x43, 0x43, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x31, 0x45, 0x39, 0x41, 0x34, 0x33, 0x30, 0x46, + 0x34, 0x30, 0x43, 0x45, 0x36, 0x36, 0x33, 0x32, 0x43, 0x39, 0x39, 0x46, + 0x43, 0x32, 0x35, 0x32, 0x34, 0x30, 0x33, 0x36, 0x30, 0x46, 0x42, 0x46, + 0x41, 0x31, 0x33, 0x31, 0x37, 0x35, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x35, + 0x39, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x34, + 0x36, 0x30, 0x41, 0x37, 0x31, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x45, 0x32, 0x36, 0x30, 0x30, 0x38, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x46, 0x31, 0x37, 0x37, 0x30, + 0x34, 0x30, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x36, + 0x41, 0x38, 0x30, 0x31, 0x42, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x30, 0x31, 0x41, 0x30, 0x32, 0x33, 0x38, 0x32, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x45, 0x41, 0x33, 0x32, 0x43, + 0x37, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x42, + 0x34, 0x30, 0x42, 0x33, 0x42, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x34, 0x32, 0x36, 0x35, 0x30, 0x34, 0x43, 0x34, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x45, 0x31, 0x31, 0x42, 0x37, + 0x36, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x32, + 0x39, 0x38, 0x30, 0x32, 0x41, 0x34, 0x35, 0x34, 0x30, 0x0a, 0x35, 0x39, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x33, + 0x36, 0x32, 0x35, 0x46, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x44, 0x30, 0x35, 0x45, 0x39, 0x34, 0x37, 0x30, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x39, 0x46, 0x42, 0x43, 0x39, 0x43, + 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x38, 0x35, + 0x38, 0x39, 0x36, 0x41, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x38, 0x36, 0x33, 0x42, 0x39, 0x39, 0x45, 0x33, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x32, 0x45, 0x33, 0x32, 0x46, 0x42, + 0x31, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x42, + 0x36, 0x41, 0x32, 0x31, 0x31, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x43, 0x32, 0x30, 0x32, 0x33, 0x31, 0x43, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x46, 0x37, 0x46, 0x43, 0x45, + 0x32, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, + 0x46, 0x45, 0x42, 0x31, 0x45, 0x45, 0x33, 0x46, 0x0a, 0x35, 0x39, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x33, 0x34, 0x32, + 0x39, 0x44, 0x36, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x43, 0x46, 0x39, 0x42, 0x33, 0x43, 0x38, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x34, 0x44, 0x46, 0x31, 0x45, 0x31, 0x37, 0x34, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x38, 0x33, + 0x30, 0x45, 0x36, 0x31, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x30, 0x45, 0x46, 0x44, 0x45, 0x33, 0x35, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x35, 0x41, 0x31, 0x43, 0x44, + 0x34, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, 0x36, 0x34, 0x32, + 0x44, 0x39, 0x39, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x34, 0x45, 0x30, 0x42, 0x39, 0x41, 0x36, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x37, 0x37, 0x41, 0x36, 0x32, 0x46, 0x34, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x44, 0x35, 0x31, + 0x42, 0x38, 0x35, 0x35, 0x36, 0x34, 0x30, 0x0a, 0x35, 0x39, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x46, 0x36, 0x45, 0x44, + 0x44, 0x46, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, + 0x33, 0x46, 0x39, 0x43, 0x41, 0x30, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x44, 0x37, 0x43, 0x30, 0x35, 0x34, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x38, 0x33, + 0x39, 0x43, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x41, 0x41, 0x45, 0x35, 0x45, 0x42, 0x30, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x41, 0x32, 0x39, 0x45, 0x36, 0x41, 0x38, 0x35, 0x31, + 0x34, 0x30, 0x0a, 0x35, 0x39, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x43, 0x38, 0x34, 0x33, 0x45, 0x30, 0x39, 0x34, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x34, 0x38, 0x37, 0x44, 0x42, + 0x46, 0x32, 0x34, 0x34, 0x30, 0x35, 0x30, 0x33, 0x44, 0x38, 0x44, 0x36, + 0x30, 0x32, 0x38, 0x32, 0x34, 0x34, 0x39, 0x34, 0x30, 0x35, 0x36, 0x41, + 0x42, 0x45, 0x43, 0x44, 0x46, 0x34, 0x45, 0x32, 0x42, 0x34, 0x30, 0x34, + 0x30, 0x0a, 0x36, 0x30, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x43, 0x41, 0x39, 0x30, 0x37, 0x42, 0x37, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x32, 0x32, 0x39, 0x34, 0x43, 0x33, + 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x35, 0x45, + 0x41, 0x35, 0x36, 0x32, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x43, 0x30, 0x34, 0x32, 0x34, 0x43, 0x42, 0x35, 0x38, 0x34, 0x30, + 0x42, 0x38, 0x34, 0x41, 0x37, 0x33, 0x37, 0x44, 0x36, 0x41, 0x42, 0x33, + 0x34, 0x37, 0x34, 0x30, 0x45, 0x37, 0x36, 0x37, 0x44, 0x43, 0x42, 0x42, + 0x42, 0x30, 0x33, 0x33, 0x35, 0x35, 0x34, 0x30, 0x0a, 0x36, 0x30, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x32, 0x46, 0x36, 0x31, + 0x46, 0x44, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x45, 0x30, 0x30, 0x43, 0x38, 0x38, 0x35, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x41, 0x37, 0x31, 0x32, 0x41, 0x34, 0x35, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x35, 0x35, 0x35, + 0x32, 0x34, 0x44, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x30, 0x31, 0x45, 0x46, 0x34, 0x31, 0x38, 0x32, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x32, 0x43, 0x43, 0x32, 0x45, 0x46, 0x34, 0x35, + 0x31, 0x34, 0x30, 0x0a, 0x36, 0x30, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x41, 0x31, 0x35, 0x42, 0x34, 0x30, 0x32, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x45, 0x38, 0x33, 0x36, + 0x36, 0x32, 0x35, 0x38, 0x34, 0x30, 0x45, 0x38, 0x36, 0x37, 0x42, 0x36, + 0x42, 0x30, 0x33, 0x41, 0x32, 0x42, 0x34, 0x32, 0x34, 0x30, 0x35, 0x31, + 0x42, 0x44, 0x46, 0x41, 0x39, 0x46, 0x45, 0x36, 0x31, 0x39, 0x35, 0x30, + 0x34, 0x30, 0x0a, 0x36, 0x30, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x30, 0x37, 0x30, 0x35, 0x44, 0x35, 0x41, 0x33, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, 0x32, 0x43, 0x46, 0x32, 0x33, + 0x37, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, + 0x41, 0x30, 0x36, 0x36, 0x41, 0x33, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x38, 0x36, 0x42, 0x41, 0x30, 0x46, 0x35, 0x35, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x38, 0x35, 0x35, 0x30, 0x41, + 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x41, 0x33, 0x30, 0x39, 0x34, 0x30, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x36, 0x36, 0x43, 0x36, 0x38, 0x37, 0x42, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x45, 0x43, 0x46, 0x35, 0x44, + 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x44, + 0x42, 0x46, 0x33, 0x33, 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x41, 0x46, 0x30, 0x38, 0x36, 0x44, 0x45, 0x35, 0x37, 0x34, + 0x30, 0x0a, 0x36, 0x30, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x36, 0x39, 0x34, 0x33, 0x30, 0x46, 0x35, 0x34, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x34, 0x39, 0x33, 0x33, 0x34, + 0x32, 0x32, 0x34, 0x30, 0x38, 0x32, 0x42, 0x44, 0x38, 0x36, 0x37, 0x34, + 0x35, 0x37, 0x39, 0x44, 0x34, 0x44, 0x34, 0x30, 0x36, 0x41, 0x44, 0x32, + 0x46, 0x34, 0x34, 0x35, 0x39, 0x37, 0x38, 0x37, 0x32, 0x46, 0x34, 0x30, + 0x0a, 0x36, 0x30, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x42, 0x36, 0x33, 0x36, 0x35, 0x31, 0x30, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x38, 0x43, 0x42, 0x46, 0x36, 0x42, 0x39, 0x35, + 0x35, 0x34, 0x30, 0x37, 0x34, 0x39, 0x41, 0x41, 0x44, 0x42, 0x45, 0x31, + 0x35, 0x39, 0x41, 0x32, 0x46, 0x34, 0x30, 0x38, 0x33, 0x39, 0x44, 0x37, + 0x46, 0x41, 0x36, 0x43, 0x31, 0x32, 0x46, 0x33, 0x43, 0x34, 0x30, 0x0a, + 0x36, 0x30, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x42, 0x46, 0x34, 0x38, 0x44, 0x37, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x30, 0x36, 0x30, 0x35, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x41, 0x38, 0x42, 0x33, 0x38, + 0x42, 0x42, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, + 0x38, 0x31, 0x32, 0x43, 0x45, 0x41, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x34, 0x35, 0x38, 0x36, 0x33, 0x41, 0x37, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x44, 0x45, 0x36, 0x34, + 0x30, 0x30, 0x33, 0x34, 0x34, 0x30, 0x44, 0x38, 0x33, 0x33, 0x35, 0x34, + 0x32, 0x45, 0x30, 0x46, 0x43, 0x30, 0x35, 0x37, 0x34, 0x30, 0x44, 0x31, + 0x42, 0x44, 0x39, 0x44, 0x34, 0x39, 0x45, 0x33, 0x43, 0x36, 0x33, 0x35, + 0x34, 0x30, 0x0a, 0x36, 0x30, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x45, 0x39, 0x34, 0x31, 0x31, 0x39, 0x44, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x34, 0x42, 0x35, 0x32, 0x33, + 0x46, 0x31, 0x45, 0x34, 0x30, 0x39, 0x45, 0x30, 0x30, 0x42, 0x33, 0x42, + 0x30, 0x46, 0x41, 0x36, 0x39, 0x34, 0x43, 0x34, 0x30, 0x36, 0x34, 0x44, + 0x44, 0x31, 0x38, 0x38, 0x41, 0x42, 0x31, 0x35, 0x36, 0x34, 0x43, 0x34, + 0x30, 0x0a, 0x36, 0x30, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x41, 0x39, 0x30, 0x46, 0x42, 0x45, 0x41, 0x35, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x30, 0x35, 0x30, 0x30, 0x46, 0x45, + 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x33, 0x46, + 0x42, 0x45, 0x35, 0x42, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x39, 0x34, 0x34, 0x35, 0x36, 0x44, 0x35, 0x30, 0x34, 0x30, + 0x0a, 0x36, 0x30, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x43, 0x36, 0x46, 0x39, 0x30, 0x31, 0x31, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x30, 0x32, 0x44, 0x39, 0x43, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x35, 0x46, 0x31, + 0x44, 0x34, 0x42, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x30, 0x37, 0x32, 0x45, 0x39, 0x45, 0x35, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x38, 0x43, 0x31, 0x46, 0x33, 0x45, 0x41, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x46, 0x43, + 0x31, 0x32, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x36, 0x36, 0x32, 0x33, 0x34, 0x30, 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x38, 0x33, 0x37, 0x42, 0x30, 0x32, + 0x36, 0x34, 0x30, 0x0a, 0x36, 0x31, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x34, 0x41, 0x44, 0x31, 0x32, 0x36, 0x43, 0x34, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x34, 0x34, 0x33, 0x31, + 0x41, 0x39, 0x31, 0x41, 0x34, 0x30, 0x39, 0x44, 0x45, 0x31, 0x45, 0x37, + 0x31, 0x33, 0x32, 0x45, 0x39, 0x37, 0x35, 0x35, 0x34, 0x30, 0x31, 0x45, + 0x33, 0x32, 0x42, 0x37, 0x46, 0x30, 0x41, 0x41, 0x42, 0x41, 0x34, 0x31, + 0x34, 0x30, 0x0a, 0x36, 0x31, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x38, 0x36, 0x39, 0x45, 0x36, 0x37, 0x43, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x35, 0x39, 0x45, 0x38, + 0x32, 0x34, 0x45, 0x34, 0x30, 0x45, 0x33, 0x41, 0x32, 0x39, 0x41, 0x41, + 0x35, 0x33, 0x39, 0x43, 0x31, 0x34, 0x46, 0x34, 0x30, 0x34, 0x43, 0x39, + 0x43, 0x38, 0x34, 0x32, 0x35, 0x37, 0x39, 0x43, 0x42, 0x34, 0x37, 0x34, + 0x30, 0x0a, 0x36, 0x31, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x45, 0x31, 0x36, 0x39, 0x31, 0x43, 0x46, 0x35, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x42, 0x39, 0x35, 0x33, 0x39, 0x45, + 0x34, 0x34, 0x34, 0x30, 0x34, 0x31, 0x45, 0x31, 0x41, 0x45, 0x35, 0x39, + 0x45, 0x38, 0x35, 0x35, 0x34, 0x30, 0x34, 0x30, 0x39, 0x43, 0x34, 0x35, + 0x33, 0x42, 0x39, 0x33, 0x35, 0x37, 0x32, 0x31, 0x32, 0x44, 0x34, 0x30, + 0x0a, 0x36, 0x31, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x36, 0x37, 0x42, 0x34, 0x43, 0x45, 0x46, 0x32, 0x33, 0x46, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x43, 0x39, 0x37, 0x33, 0x30, 0x43, 0x30, 0x34, + 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x41, 0x30, 0x46, 0x44, + 0x45, 0x32, 0x34, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x43, 0x35, 0x33, 0x41, 0x36, 0x42, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x38, 0x42, 0x38, 0x41, 0x39, 0x38, 0x43, 0x34, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x34, 0x36, 0x42, 0x43, + 0x39, 0x30, 0x46, 0x35, 0x34, 0x34, 0x30, 0x0a, 0x36, 0x31, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x46, 0x38, 0x45, 0x33, + 0x37, 0x45, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, + 0x35, 0x35, 0x44, 0x32, 0x46, 0x42, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x43, 0x39, 0x44, 0x36, 0x41, 0x44, 0x38, 0x34, 0x45, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x46, 0x39, 0x45, + 0x41, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x32, + 0x34, 0x30, 0x31, 0x32, 0x41, 0x32, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x30, 0x43, 0x33, 0x34, 0x38, 0x31, 0x32, 0x32, 0x43, + 0x34, 0x30, 0x0a, 0x36, 0x31, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x41, 0x46, 0x34, 0x36, 0x45, 0x33, 0x34, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x45, 0x42, 0x45, 0x35, 0x41, + 0x32, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x32, + 0x42, 0x39, 0x37, 0x35, 0x42, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x35, 0x43, 0x31, 0x33, 0x34, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x30, 0x41, 0x41, 0x38, 0x33, + 0x44, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x32, + 0x30, 0x38, 0x35, 0x36, 0x36, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x34, 0x31, 0x30, 0x31, 0x34, 0x36, 0x42, 0x34, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x41, 0x38, 0x42, 0x42, + 0x35, 0x30, 0x30, 0x34, 0x30, 0x0a, 0x36, 0x31, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x34, 0x35, 0x36, 0x30, 0x43, 0x39, + 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x31, 0x33, + 0x31, 0x36, 0x30, 0x32, 0x35, 0x30, 0x34, 0x30, 0x45, 0x41, 0x30, 0x35, + 0x45, 0x34, 0x38, 0x31, 0x37, 0x30, 0x41, 0x44, 0x35, 0x34, 0x34, 0x30, + 0x42, 0x30, 0x42, 0x37, 0x37, 0x37, 0x39, 0x43, 0x38, 0x32, 0x46, 0x32, + 0x34, 0x41, 0x34, 0x30, 0x0a, 0x36, 0x31, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x36, 0x46, 0x32, 0x43, 0x39, 0x31, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x41, 0x36, 0x31, + 0x43, 0x37, 0x44, 0x33, 0x36, 0x34, 0x30, 0x33, 0x35, 0x31, 0x39, 0x36, + 0x42, 0x41, 0x45, 0x35, 0x32, 0x31, 0x42, 0x33, 0x30, 0x34, 0x30, 0x42, + 0x35, 0x37, 0x39, 0x45, 0x33, 0x34, 0x36, 0x33, 0x39, 0x42, 0x30, 0x34, + 0x33, 0x34, 0x30, 0x0a, 0x36, 0x31, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x43, 0x43, 0x46, 0x33, 0x34, 0x46, 0x32, 0x35, 0x34, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x45, 0x43, 0x31, 0x42, 0x36, + 0x39, 0x36, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x39, 0x41, 0x33, 0x39, 0x45, 0x37, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x32, 0x39, 0x32, 0x41, 0x37, 0x37, 0x34, 0x42, + 0x34, 0x30, 0x34, 0x45, 0x31, 0x31, 0x36, 0x44, 0x36, 0x42, 0x38, 0x36, + 0x39, 0x30, 0x33, 0x44, 0x34, 0x30, 0x44, 0x43, 0x44, 0x42, 0x42, 0x46, + 0x46, 0x46, 0x42, 0x44, 0x36, 0x35, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x36, + 0x31, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x30, + 0x31, 0x43, 0x45, 0x41, 0x44, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x41, 0x41, 0x31, 0x34, 0x38, 0x42, 0x33, 0x35, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x33, 0x45, 0x45, 0x41, + 0x30, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x46, + 0x46, 0x34, 0x34, 0x46, 0x38, 0x35, 0x38, 0x34, 0x30, 0x43, 0x35, 0x43, + 0x37, 0x35, 0x45, 0x30, 0x45, 0x46, 0x45, 0x43, 0x45, 0x34, 0x32, 0x34, + 0x30, 0x43, 0x33, 0x43, 0x44, 0x30, 0x34, 0x44, 0x31, 0x42, 0x41, 0x30, + 0x41, 0x34, 0x42, 0x34, 0x30, 0x0a, 0x36, 0x32, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x34, 0x46, 0x31, 0x46, 0x41, 0x42, + 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x36, 0x33, + 0x30, 0x46, 0x44, 0x36, 0x32, 0x31, 0x34, 0x30, 0x33, 0x43, 0x33, 0x35, + 0x45, 0x45, 0x37, 0x34, 0x32, 0x32, 0x44, 0x38, 0x34, 0x42, 0x34, 0x30, + 0x37, 0x30, 0x38, 0x38, 0x44, 0x31, 0x43, 0x43, 0x39, 0x39, 0x35, 0x42, + 0x34, 0x39, 0x34, 0x30, 0x0a, 0x36, 0x32, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x37, 0x37, 0x33, 0x31, 0x43, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x37, 0x45, 0x37, + 0x39, 0x33, 0x38, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x38, 0x31, 0x37, 0x36, 0x38, 0x32, 0x35, 0x33, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x32, 0x32, 0x34, 0x46, 0x33, 0x44, 0x34, 0x35, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x34, 0x35, + 0x33, 0x42, 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x35, 0x45, 0x43, 0x43, 0x43, 0x31, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x34, 0x41, 0x36, 0x33, 0x36, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x35, 0x44, + 0x38, 0x37, 0x35, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x36, 0x32, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x43, 0x43, 0x34, 0x34, + 0x43, 0x37, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x34, + 0x46, 0x41, 0x41, 0x41, 0x37, 0x39, 0x34, 0x31, 0x34, 0x30, 0x46, 0x33, + 0x37, 0x41, 0x43, 0x31, 0x41, 0x42, 0x34, 0x37, 0x35, 0x43, 0x34, 0x42, + 0x34, 0x30, 0x31, 0x33, 0x30, 0x46, 0x46, 0x46, 0x36, 0x33, 0x42, 0x30, + 0x42, 0x44, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x36, 0x32, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x32, 0x38, 0x44, 0x38, 0x35, + 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x33, + 0x33, 0x33, 0x31, 0x45, 0x42, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x34, 0x36, 0x33, 0x32, 0x34, 0x41, 0x32, 0x35, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x34, 0x37, 0x35, 0x39, 0x44, 0x31, + 0x46, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x36, 0x32, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x41, 0x30, 0x37, 0x37, 0x43, 0x31, + 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x36, 0x39, + 0x42, 0x34, 0x37, 0x37, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x45, 0x35, 0x39, 0x33, 0x42, 0x39, 0x35, 0x35, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x33, 0x31, 0x34, 0x34, 0x31, 0x35, + 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x32, 0x36, + 0x42, 0x36, 0x44, 0x34, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x32, 0x31, 0x38, 0x36, 0x44, 0x38, 0x33, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x45, 0x41, 0x34, 0x41, 0x30, + 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x45, 0x41, + 0x35, 0x42, 0x42, 0x30, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x42, 0x37, 0x44, 0x34, 0x46, 0x45, 0x31, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x33, 0x31, 0x41, 0x31, 0x31, + 0x33, 0x38, 0x34, 0x30, 0x0a, 0x36, 0x32, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x36, 0x36, 0x34, 0x39, 0x42, 0x46, 0x35, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x33, 0x35, 0x33, + 0x35, 0x30, 0x37, 0x34, 0x46, 0x34, 0x30, 0x31, 0x33, 0x31, 0x34, 0x43, + 0x44, 0x35, 0x43, 0x44, 0x37, 0x35, 0x39, 0x35, 0x32, 0x34, 0x30, 0x44, + 0x41, 0x45, 0x37, 0x44, 0x44, 0x42, 0x33, 0x39, 0x39, 0x39, 0x44, 0x35, + 0x31, 0x34, 0x30, 0x0a, 0x36, 0x32, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x38, 0x41, 0x32, 0x38, 0x43, 0x36, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x32, 0x37, 0x31, 0x34, + 0x35, 0x45, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x38, 0x32, 0x31, 0x44, 0x44, 0x37, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x36, 0x43, 0x36, 0x34, 0x37, 0x32, 0x41, 0x35, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x32, 0x41, 0x44, 0x33, + 0x42, 0x35, 0x31, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, + 0x30, 0x45, 0x35, 0x42, 0x45, 0x36, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x36, + 0x32, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x34, 0x35, 0x35, 0x35, 0x46, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x30, 0x30, 0x42, 0x45, 0x33, 0x39, 0x31, 0x32, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x31, 0x32, 0x43, 0x41, 0x37, + 0x43, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x42, + 0x42, 0x41, 0x39, 0x30, 0x44, 0x34, 0x38, 0x34, 0x30, 0x35, 0x42, 0x41, + 0x41, 0x33, 0x36, 0x36, 0x42, 0x35, 0x39, 0x42, 0x45, 0x35, 0x32, 0x34, + 0x30, 0x42, 0x39, 0x31, 0x37, 0x34, 0x41, 0x31, 0x35, 0x46, 0x45, 0x41, + 0x42, 0x34, 0x39, 0x34, 0x30, 0x0a, 0x36, 0x32, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x43, 0x32, 0x30, 0x35, 0x41, 0x37, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x38, 0x38, + 0x38, 0x44, 0x33, 0x42, 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x45, 0x37, 0x43, 0x43, 0x38, 0x46, 0x38, 0x33, 0x46, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x42, 0x41, 0x34, 0x30, 0x35, 0x35, + 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x41, 0x36, 0x31, + 0x44, 0x35, 0x37, 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x36, 0x38, 0x46, 0x46, 0x38, 0x36, 0x36, 0x35, 0x36, 0x34, 0x30, + 0x0a, 0x36, 0x32, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x32, 0x46, 0x38, 0x41, 0x35, 0x46, 0x44, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x45, 0x34, 0x45, 0x43, 0x43, 0x42, 0x33, 0x35, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, 0x45, 0x44, 0x37, + 0x38, 0x46, 0x39, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x41, 0x36, 0x32, 0x45, 0x42, 0x35, 0x33, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x36, 0x33, 0x31, 0x46, 0x34, 0x33, 0x46, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, 0x36, 0x37, 0x36, + 0x39, 0x36, 0x34, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x38, 0x39, 0x45, 0x46, 0x45, 0x44, 0x42, 0x33, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x36, 0x33, 0x42, 0x37, 0x39, 0x39, 0x37, 0x35, + 0x37, 0x34, 0x30, 0x0a, 0x36, 0x33, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x38, 0x36, 0x45, 0x34, 0x37, 0x36, 0x31, 0x35, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x41, 0x30, 0x39, 0x42, + 0x42, 0x35, 0x46, 0x30, 0x33, 0x46, 0x35, 0x46, 0x43, 0x41, 0x32, 0x43, + 0x44, 0x41, 0x46, 0x36, 0x32, 0x38, 0x32, 0x32, 0x34, 0x30, 0x37, 0x34, + 0x38, 0x31, 0x43, 0x31, 0x34, 0x44, 0x43, 0x39, 0x34, 0x46, 0x34, 0x30, + 0x34, 0x30, 0x0a, 0x36, 0x33, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x35, 0x37, 0x38, 0x32, 0x42, 0x36, 0x33, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x30, 0x39, 0x35, 0x38, 0x34, + 0x46, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x30, + 0x38, 0x43, 0x32, 0x44, 0x45, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x38, 0x34, 0x38, 0x34, 0x45, 0x42, 0x36, 0x34, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, 0x43, 0x35, 0x44, 0x46, + 0x36, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x43, + 0x38, 0x32, 0x37, 0x30, 0x44, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x38, 0x32, 0x46, 0x39, 0x32, 0x37, 0x43, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x41, 0x35, 0x46, 0x38, 0x38, + 0x33, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x36, 0x33, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x34, 0x45, 0x38, 0x33, 0x34, 0x41, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x39, 0x39, + 0x39, 0x32, 0x46, 0x36, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x36, 0x33, 0x46, 0x30, 0x46, 0x37, 0x37, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x44, 0x35, 0x33, 0x37, 0x36, 0x34, + 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x45, 0x39, + 0x30, 0x38, 0x44, 0x33, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x30, 0x34, 0x33, 0x46, 0x35, 0x39, 0x35, 0x34, 0x44, 0x34, 0x30, + 0x0a, 0x36, 0x33, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x38, 0x36, 0x41, 0x45, 0x36, 0x34, 0x33, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x32, 0x34, 0x39, 0x46, 0x41, 0x30, 0x31, 0x35, + 0x35, 0x34, 0x30, 0x33, 0x32, 0x32, 0x33, 0x33, 0x39, 0x30, 0x38, 0x41, + 0x30, 0x34, 0x35, 0x34, 0x43, 0x34, 0x30, 0x31, 0x37, 0x46, 0x42, 0x45, + 0x42, 0x30, 0x41, 0x34, 0x41, 0x45, 0x30, 0x35, 0x31, 0x34, 0x30, 0x0a, + 0x36, 0x33, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, + 0x33, 0x44, 0x38, 0x33, 0x35, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x43, 0x34, 0x30, 0x36, 0x42, 0x34, 0x39, 0x34, 0x34, + 0x34, 0x30, 0x39, 0x45, 0x42, 0x35, 0x31, 0x44, 0x37, 0x36, 0x37, 0x38, + 0x37, 0x37, 0x34, 0x35, 0x34, 0x30, 0x38, 0x41, 0x46, 0x36, 0x32, 0x42, + 0x41, 0x35, 0x32, 0x30, 0x45, 0x41, 0x34, 0x42, 0x34, 0x30, 0x0a, 0x36, + 0x33, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x36, + 0x44, 0x37, 0x42, 0x37, 0x34, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x44, 0x43, 0x38, 0x44, 0x30, 0x34, 0x32, 0x35, 0x34, + 0x30, 0x46, 0x45, 0x42, 0x31, 0x44, 0x46, 0x41, 0x36, 0x44, 0x42, 0x32, + 0x45, 0x35, 0x30, 0x34, 0x30, 0x35, 0x43, 0x39, 0x43, 0x39, 0x36, 0x35, + 0x45, 0x31, 0x41, 0x43, 0x42, 0x33, 0x41, 0x34, 0x30, 0x0a, 0x36, 0x33, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x32, + 0x39, 0x30, 0x44, 0x33, 0x32, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x43, 0x34, 0x45, 0x39, 0x32, 0x30, 0x43, 0x34, 0x32, 0x34, 0x30, + 0x32, 0x35, 0x36, 0x38, 0x39, 0x31, 0x35, 0x46, 0x36, 0x30, 0x39, 0x36, + 0x33, 0x43, 0x34, 0x30, 0x33, 0x34, 0x46, 0x34, 0x34, 0x34, 0x33, 0x41, + 0x38, 0x42, 0x38, 0x30, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x36, 0x33, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x38, 0x30, 0x41, + 0x32, 0x32, 0x42, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x38, 0x35, 0x35, 0x34, 0x38, 0x31, 0x46, 0x34, 0x41, 0x34, 0x30, 0x37, + 0x38, 0x35, 0x45, 0x38, 0x35, 0x33, 0x42, 0x36, 0x30, 0x38, 0x43, 0x32, + 0x45, 0x34, 0x30, 0x42, 0x45, 0x43, 0x39, 0x43, 0x33, 0x44, 0x33, 0x35, + 0x36, 0x32, 0x45, 0x34, 0x45, 0x34, 0x30, 0x0a, 0x36, 0x33, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x44, 0x35, 0x36, 0x46, + 0x44, 0x37, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, + 0x44, 0x39, 0x44, 0x36, 0x34, 0x33, 0x35, 0x32, 0x34, 0x30, 0x45, 0x42, + 0x41, 0x37, 0x33, 0x31, 0x37, 0x39, 0x46, 0x31, 0x32, 0x36, 0x35, 0x31, + 0x34, 0x30, 0x33, 0x42, 0x31, 0x34, 0x45, 0x33, 0x33, 0x39, 0x41, 0x42, + 0x45, 0x34, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x36, 0x33, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x45, 0x41, 0x46, 0x38, 0x36, 0x44, + 0x45, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x45, 0x31, + 0x35, 0x34, 0x43, 0x31, 0x32, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x41, 0x38, 0x39, 0x30, 0x42, 0x30, 0x34, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x46, 0x46, 0x46, 0x41, 0x45, + 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x38, + 0x30, 0x45, 0x30, 0x34, 0x33, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x32, 0x42, 0x37, 0x30, 0x39, 0x42, 0x34, 0x39, 0x34, + 0x30, 0x42, 0x45, 0x33, 0x42, 0x31, 0x32, 0x41, 0x32, 0x41, 0x45, 0x34, + 0x34, 0x34, 0x36, 0x34, 0x30, 0x43, 0x35, 0x46, 0x39, 0x46, 0x46, 0x33, + 0x31, 0x36, 0x41, 0x38, 0x34, 0x34, 0x34, 0x34, 0x30, 0x0a, 0x36, 0x34, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x32, 0x43, 0x34, + 0x32, 0x35, 0x45, 0x42, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x41, 0x32, 0x32, 0x45, 0x30, 0x42, 0x45, 0x35, 0x30, 0x34, 0x30, + 0x36, 0x35, 0x37, 0x31, 0x44, 0x38, 0x42, 0x46, 0x41, 0x42, 0x36, 0x43, + 0x35, 0x35, 0x34, 0x30, 0x46, 0x30, 0x38, 0x30, 0x43, 0x32, 0x33, 0x35, + 0x43, 0x38, 0x44, 0x33, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x36, 0x34, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x38, 0x43, 0x32, + 0x33, 0x34, 0x42, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x45, 0x31, 0x43, 0x31, 0x43, 0x42, 0x32, 0x45, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x45, 0x45, 0x39, 0x39, 0x34, 0x33, 0x31, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x44, 0x32, 0x45, + 0x42, 0x36, 0x43, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x38, 0x43, 0x37, 0x39, 0x41, 0x45, 0x33, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x30, 0x44, 0x39, 0x42, 0x36, 0x35, 0x38, 0x32, + 0x45, 0x34, 0x30, 0x0a, 0x36, 0x34, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x43, 0x35, 0x39, 0x32, 0x31, 0x36, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x38, 0x32, 0x35, 0x46, + 0x38, 0x34, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, + 0x36, 0x36, 0x33, 0x31, 0x34, 0x30, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x38, 0x34, 0x36, 0x46, 0x37, 0x46, 0x35, 0x34, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x37, 0x44, 0x42, 0x38, + 0x39, 0x30, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, + 0x31, 0x31, 0x30, 0x34, 0x45, 0x46, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x36, + 0x34, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x43, + 0x33, 0x45, 0x44, 0x45, 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x30, 0x30, 0x46, 0x44, 0x34, 0x45, 0x45, 0x34, 0x46, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x35, 0x39, 0x43, 0x35, + 0x32, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x45, + 0x35, 0x43, 0x44, 0x41, 0x36, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x36, 0x34, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x38, + 0x42, 0x36, 0x34, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x46, 0x41, 0x42, 0x37, 0x44, 0x38, 0x32, 0x42, 0x34, 0x30, + 0x31, 0x33, 0x43, 0x36, 0x31, 0x42, 0x34, 0x45, 0x38, 0x32, 0x33, 0x41, + 0x34, 0x45, 0x34, 0x30, 0x42, 0x39, 0x42, 0x34, 0x31, 0x45, 0x33, 0x44, + 0x37, 0x30, 0x46, 0x32, 0x32, 0x38, 0x34, 0x30, 0x0a, 0x36, 0x34, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x34, 0x35, 0x34, + 0x42, 0x45, 0x43, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x38, 0x34, 0x38, 0x38, 0x44, 0x30, 0x33, 0x46, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x36, 0x38, 0x36, 0x46, 0x44, 0x44, 0x34, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x44, 0x46, + 0x36, 0x35, 0x43, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x45, 0x41, 0x42, 0x39, 0x35, 0x30, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x32, 0x46, 0x32, 0x39, 0x46, 0x34, + 0x34, 0x34, 0x30, 0x45, 0x36, 0x35, 0x35, 0x45, 0x46, 0x38, 0x43, 0x32, + 0x38, 0x36, 0x38, 0x34, 0x33, 0x34, 0x30, 0x42, 0x46, 0x38, 0x39, 0x34, + 0x45, 0x43, 0x43, 0x45, 0x43, 0x36, 0x46, 0x34, 0x43, 0x34, 0x30, 0x0a, + 0x36, 0x34, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x32, 0x46, 0x30, 0x35, 0x44, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x38, 0x33, 0x33, 0x44, 0x37, 0x43, 0x39, 0x33, 0x39, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x32, 0x37, 0x32, 0x39, + 0x37, 0x36, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, + 0x38, 0x37, 0x38, 0x41, 0x45, 0x37, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x42, 0x39, 0x32, 0x37, 0x39, 0x32, 0x33, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x42, 0x34, 0x42, 0x36, + 0x36, 0x30, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x36, 0x34, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x45, 0x35, 0x43, 0x44, 0x44, + 0x32, 0x34, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x32, + 0x34, 0x30, 0x36, 0x45, 0x37, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x38, 0x35, 0x43, 0x33, 0x32, 0x30, 0x39, 0x34, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x43, 0x31, 0x37, 0x33, 0x34, + 0x39, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x41, + 0x37, 0x44, 0x42, 0x36, 0x33, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x38, 0x43, 0x45, 0x39, 0x31, 0x43, 0x33, 0x33, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x43, 0x41, 0x38, 0x34, 0x36, + 0x41, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x42, + 0x33, 0x44, 0x36, 0x30, 0x44, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x43, 0x37, 0x41, 0x35, 0x46, 0x31, 0x46, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x31, 0x43, 0x35, 0x35, + 0x46, 0x31, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, + 0x33, 0x45, 0x34, 0x35, 0x36, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x46, 0x45, 0x39, 0x32, 0x44, 0x45, 0x35, 0x37, 0x34, + 0x30, 0x0a, 0x36, 0x34, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x42, 0x31, 0x32, 0x44, 0x31, 0x38, 0x33, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x39, 0x44, 0x31, 0x31, 0x36, + 0x33, 0x32, 0x34, 0x30, 0x45, 0x43, 0x46, 0x45, 0x41, 0x44, 0x36, 0x30, + 0x39, 0x30, 0x37, 0x38, 0x34, 0x33, 0x34, 0x30, 0x41, 0x36, 0x34, 0x33, + 0x35, 0x46, 0x42, 0x39, 0x45, 0x31, 0x31, 0x34, 0x33, 0x42, 0x34, 0x30, + 0x0a, 0x36, 0x34, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x38, 0x35, 0x36, 0x43, 0x42, 0x30, 0x33, 0x34, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x34, 0x35, 0x34, 0x35, 0x39, 0x43, 0x41, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x42, 0x43, 0x45, + 0x30, 0x36, 0x45, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x30, 0x45, 0x30, 0x43, 0x39, 0x42, 0x34, 0x31, 0x45, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x43, 0x44, 0x42, 0x38, 0x37, 0x42, 0x34, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x33, 0x43, + 0x46, 0x39, 0x42, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x46, 0x44, 0x30, 0x43, 0x32, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x32, 0x33, 0x41, 0x43, 0x41, 0x36, 0x46, 0x35, + 0x33, 0x34, 0x30, 0x0a, 0x36, 0x35, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x45, 0x34, 0x34, 0x38, 0x34, 0x35, 0x35, 0x34, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x41, 0x32, 0x41, 0x43, + 0x42, 0x35, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x43, 0x35, 0x45, 0x45, 0x31, 0x44, 0x32, 0x43, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x41, 0x33, 0x34, 0x34, 0x35, 0x43, 0x42, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x45, 0x31, 0x37, 0x39, 0x41, + 0x43, 0x44, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x42, 0x42, 0x38, 0x36, 0x31, 0x32, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x34, 0x30, 0x31, 0x46, 0x46, 0x32, 0x31, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x39, 0x36, + 0x34, 0x45, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x37, 0x37, 0x31, 0x34, 0x41, 0x30, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x41, 0x31, 0x43, 0x33, 0x31, 0x42, 0x34, 0x44, + 0x34, 0x30, 0x0a, 0x36, 0x35, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x34, 0x32, 0x32, 0x35, 0x31, 0x37, 0x37, 0x34, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x38, 0x31, 0x43, 0x31, 0x35, + 0x35, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x37, + 0x44, 0x43, 0x33, 0x39, 0x44, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x34, 0x36, 0x34, 0x41, 0x34, 0x42, 0x30, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x45, 0x43, 0x41, 0x43, 0x32, + 0x42, 0x32, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x35, + 0x44, 0x38, 0x46, 0x46, 0x33, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x36, 0x35, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, 0x31, + 0x43, 0x35, 0x44, 0x32, 0x31, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x44, 0x43, 0x36, 0x42, 0x32, 0x33, 0x39, 0x37, 0x35, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x42, 0x44, 0x33, + 0x42, 0x30, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x39, 0x31, + 0x35, 0x30, 0x35, 0x31, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x30, 0x32, 0x44, 0x31, 0x32, 0x33, 0x32, 0x34, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x33, 0x33, 0x38, 0x45, 0x43, 0x45, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x31, 0x33, + 0x32, 0x34, 0x35, 0x45, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x34, 0x36, 0x39, 0x41, 0x42, 0x30, 0x38, 0x34, 0x42, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x44, 0x35, 0x31, 0x38, + 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x42, 0x44, + 0x30, 0x42, 0x32, 0x43, 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x33, 0x34, 0x35, 0x43, 0x39, 0x34, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x41, 0x34, 0x41, 0x36, 0x45, 0x31, + 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x34, 0x44, + 0x36, 0x31, 0x45, 0x46, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x34, 0x31, 0x38, 0x41, 0x35, 0x44, 0x39, 0x35, 0x33, 0x34, 0x30, + 0x0a, 0x36, 0x35, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x32, 0x36, 0x31, 0x46, 0x37, 0x33, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x45, 0x34, 0x43, 0x45, 0x41, 0x41, 0x34, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x32, 0x32, + 0x34, 0x30, 0x34, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x43, 0x46, 0x44, 0x36, 0x46, 0x44, 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x34, 0x41, 0x37, 0x44, 0x37, 0x33, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x38, 0x35, + 0x34, 0x41, 0x38, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x36, 0x35, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x32, 0x39, 0x44, 0x43, 0x42, + 0x43, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, + 0x43, 0x34, 0x41, 0x41, 0x34, 0x45, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x42, 0x30, 0x35, 0x41, 0x33, 0x42, 0x46, 0x32, 0x34, 0x43, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x33, 0x46, 0x31, 0x41, + 0x33, 0x33, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, + 0x38, 0x34, 0x44, 0x43, 0x44, 0x38, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x45, 0x46, 0x46, 0x42, 0x32, 0x44, 0x30, 0x41, + 0x34, 0x30, 0x0a, 0x36, 0x35, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x44, 0x30, 0x46, 0x45, 0x45, 0x46, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x31, 0x45, 0x30, 0x32, 0x36, + 0x43, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x30, + 0x45, 0x32, 0x46, 0x42, 0x43, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x41, 0x33, 0x42, 0x32, 0x32, 0x38, 0x37, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x46, 0x44, 0x33, 0x36, 0x37, + 0x30, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, + 0x32, 0x37, 0x35, 0x34, 0x44, 0x31, 0x36, 0x34, 0x30, 0x42, 0x41, 0x41, + 0x37, 0x38, 0x33, 0x42, 0x37, 0x38, 0x38, 0x36, 0x36, 0x35, 0x30, 0x34, + 0x30, 0x43, 0x36, 0x39, 0x41, 0x34, 0x33, 0x39, 0x32, 0x30, 0x33, 0x39, + 0x30, 0x32, 0x45, 0x34, 0x30, 0x0a, 0x36, 0x35, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, 0x38, 0x30, 0x34, 0x32, 0x35, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, + 0x39, 0x45, 0x37, 0x34, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x30, 0x46, 0x45, 0x31, 0x44, 0x34, 0x46, 0x32, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x38, 0x32, 0x42, 0x32, 0x44, 0x44, + 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x31, + 0x41, 0x37, 0x46, 0x35, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x30, 0x44, 0x41, 0x33, 0x42, 0x46, 0x35, 0x31, 0x33, 0x34, 0x30, + 0x0a, 0x36, 0x35, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x30, 0x38, 0x43, 0x46, 0x44, 0x43, 0x45, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x36, 0x32, 0x33, 0x46, 0x33, 0x33, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x32, 0x46, 0x38, + 0x38, 0x43, 0x34, 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x38, 0x44, 0x45, 0x41, 0x35, 0x45, 0x43, 0x34, 0x35, 0x34, 0x30, 0x36, + 0x33, 0x45, 0x42, 0x31, 0x45, 0x42, 0x34, 0x43, 0x32, 0x31, 0x32, 0x34, + 0x39, 0x34, 0x30, 0x36, 0x45, 0x38, 0x36, 0x44, 0x30, 0x42, 0x41, 0x42, + 0x42, 0x45, 0x39, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x36, 0x35, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, 0x41, 0x38, 0x33, + 0x39, 0x37, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, + 0x37, 0x32, 0x41, 0x43, 0x38, 0x45, 0x33, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x43, 0x30, 0x35, 0x31, 0x46, 0x34, 0x37, 0x34, 0x32, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x33, 0x37, 0x45, 0x31, + 0x32, 0x41, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, + 0x44, 0x46, 0x41, 0x43, 0x30, 0x37, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x33, 0x42, 0x34, 0x42, 0x32, 0x35, 0x31, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x35, 0x33, 0x33, 0x31, + 0x30, 0x45, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, + 0x44, 0x45, 0x35, 0x44, 0x41, 0x31, 0x33, 0x30, 0x34, 0x30, 0x45, 0x39, + 0x37, 0x39, 0x31, 0x41, 0x39, 0x41, 0x36, 0x34, 0x35, 0x32, 0x34, 0x31, + 0x34, 0x30, 0x43, 0x34, 0x35, 0x36, 0x46, 0x35, 0x34, 0x42, 0x42, 0x33, + 0x36, 0x33, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x36, 0x35, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x33, 0x41, 0x39, 0x31, 0x42, + 0x43, 0x33, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x35, + 0x31, 0x34, 0x37, 0x35, 0x36, 0x34, 0x45, 0x34, 0x30, 0x42, 0x35, 0x34, + 0x34, 0x46, 0x45, 0x35, 0x32, 0x41, 0x46, 0x37, 0x44, 0x33, 0x43, 0x34, + 0x30, 0x44, 0x38, 0x44, 0x37, 0x46, 0x44, 0x31, 0x39, 0x38, 0x30, 0x42, + 0x44, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x36, 0x36, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x36, 0x44, 0x46, 0x41, 0x46, 0x42, + 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x33, 0x39, + 0x44, 0x45, 0x37, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x35, 0x38, 0x44, 0x36, 0x44, 0x42, 0x33, 0x46, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x32, 0x44, 0x44, 0x45, 0x32, 0x33, + 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x33, 0x39, + 0x31, 0x41, 0x39, 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x43, 0x42, 0x36, 0x43, 0x42, 0x37, 0x45, 0x34, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x37, 0x42, 0x39, 0x36, 0x41, 0x45, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x34, 0x36, + 0x38, 0x35, 0x46, 0x46, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x38, 0x31, 0x45, 0x37, 0x35, 0x34, 0x33, 0x34, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x34, 0x41, 0x35, 0x45, 0x36, 0x42, + 0x34, 0x33, 0x34, 0x30, 0x0a, 0x36, 0x36, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x43, 0x31, 0x42, 0x37, 0x45, 0x39, 0x45, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x33, 0x36, 0x35, + 0x36, 0x38, 0x38, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x30, 0x41, 0x35, 0x45, 0x36, 0x34, 0x42, 0x32, 0x44, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x41, 0x32, 0x43, 0x32, 0x38, 0x43, 0x34, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x44, + 0x37, 0x39, 0x32, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x38, 0x42, 0x39, 0x36, 0x37, 0x33, 0x41, 0x34, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x38, 0x34, 0x42, 0x38, 0x31, 0x43, 0x44, 0x33, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x46, 0x38, 0x38, + 0x46, 0x33, 0x38, 0x35, 0x35, 0x34, 0x30, 0x0a, 0x36, 0x36, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x30, 0x38, 0x42, 0x30, + 0x37, 0x35, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x31, 0x36, 0x32, 0x30, 0x39, 0x43, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x38, 0x37, 0x34, 0x34, 0x36, 0x38, 0x33, 0x33, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x46, 0x33, 0x41, 0x39, + 0x42, 0x33, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x45, 0x42, 0x34, 0x38, 0x39, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x34, 0x37, 0x46, 0x44, 0x42, 0x35, 0x34, 0x34, 0x41, + 0x34, 0x30, 0x0a, 0x36, 0x36, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x36, 0x33, 0x43, 0x31, 0x43, 0x44, 0x33, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x43, 0x37, 0x32, 0x37, + 0x44, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x34, + 0x43, 0x36, 0x46, 0x43, 0x33, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x36, 0x32, 0x43, 0x45, 0x45, 0x31, 0x42, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x33, 0x44, 0x39, 0x46, + 0x32, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, 0x43, + 0x32, 0x32, 0x36, 0x31, 0x41, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x45, 0x38, 0x34, 0x43, 0x34, 0x33, 0x37, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x37, 0x32, 0x39, 0x34, 0x45, + 0x30, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x46, + 0x37, 0x38, 0x31, 0x36, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x30, 0x33, 0x41, 0x36, 0x37, 0x32, 0x31, 0x37, 0x34, + 0x30, 0x0a, 0x36, 0x36, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x38, 0x34, 0x39, 0x36, 0x33, 0x41, 0x43, 0x34, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x45, 0x43, 0x39, 0x33, 0x31, + 0x34, 0x38, 0x34, 0x30, 0x43, 0x38, 0x32, 0x32, 0x39, 0x39, 0x39, 0x37, + 0x39, 0x43, 0x46, 0x37, 0x34, 0x38, 0x34, 0x30, 0x42, 0x30, 0x46, 0x31, + 0x42, 0x43, 0x44, 0x33, 0x30, 0x39, 0x33, 0x38, 0x34, 0x46, 0x34, 0x30, + 0x0a, 0x36, 0x36, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x30, 0x36, 0x43, 0x33, 0x38, 0x38, 0x41, 0x30, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x42, 0x34, 0x38, 0x32, 0x37, 0x31, 0x34, + 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x32, 0x37, 0x35, + 0x46, 0x35, 0x39, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x33, 0x38, 0x38, 0x34, 0x36, 0x46, 0x34, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x30, 0x34, 0x31, 0x44, 0x33, 0x42, 0x42, 0x32, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x36, 0x41, 0x42, + 0x36, 0x44, 0x38, 0x32, 0x31, 0x34, 0x30, 0x0a, 0x36, 0x36, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x35, 0x39, 0x36, 0x31, + 0x36, 0x38, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, + 0x39, 0x30, 0x33, 0x44, 0x35, 0x35, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x38, 0x43, 0x44, 0x37, 0x34, 0x38, 0x42, 0x35, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x37, 0x44, 0x31, 0x34, + 0x35, 0x33, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x36, 0x36, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x32, 0x44, 0x39, 0x46, 0x30, + 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x36, + 0x37, 0x38, 0x30, 0x31, 0x46, 0x32, 0x35, 0x34, 0x30, 0x45, 0x44, 0x37, + 0x30, 0x36, 0x44, 0x37, 0x44, 0x37, 0x34, 0x39, 0x42, 0x34, 0x30, 0x34, + 0x30, 0x42, 0x32, 0x46, 0x38, 0x31, 0x37, 0x34, 0x33, 0x35, 0x33, 0x36, + 0x30, 0x33, 0x34, 0x34, 0x30, 0x0a, 0x36, 0x36, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x43, 0x42, 0x30, 0x37, 0x37, 0x41, + 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x30, 0x39, + 0x39, 0x41, 0x42, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x38, 0x33, 0x46, 0x42, 0x39, 0x38, 0x43, 0x35, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x34, 0x32, 0x37, 0x30, 0x35, + 0x33, 0x46, 0x34, 0x30, 0x36, 0x36, 0x31, 0x44, 0x33, 0x32, 0x35, 0x38, + 0x32, 0x30, 0x36, 0x30, 0x34, 0x44, 0x34, 0x30, 0x32, 0x46, 0x35, 0x32, + 0x33, 0x39, 0x31, 0x33, 0x45, 0x46, 0x39, 0x38, 0x35, 0x30, 0x34, 0x30, + 0x0a, 0x36, 0x36, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x38, 0x38, 0x44, 0x30, 0x35, 0x42, 0x39, 0x34, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x43, 0x35, 0x42, 0x41, 0x34, 0x43, 0x34, 0x34, + 0x46, 0x34, 0x30, 0x35, 0x31, 0x35, 0x31, 0x44, 0x43, 0x45, 0x45, 0x41, + 0x41, 0x44, 0x45, 0x34, 0x31, 0x34, 0x30, 0x31, 0x46, 0x46, 0x45, 0x33, + 0x37, 0x42, 0x37, 0x34, 0x34, 0x31, 0x45, 0x34, 0x44, 0x34, 0x30, 0x0a, + 0x36, 0x37, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x43, 0x37, 0x38, 0x43, 0x46, 0x37, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x30, 0x32, 0x43, 0x37, 0x33, 0x44, 0x31, 0x33, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x41, 0x36, 0x31, 0x37, + 0x30, 0x46, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x32, + 0x37, 0x31, 0x39, 0x43, 0x30, 0x41, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x33, 0x38, 0x34, 0x44, 0x36, 0x42, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x37, 0x32, 0x41, 0x43, + 0x46, 0x30, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x36, 0x37, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x33, 0x30, 0x34, 0x32, 0x46, + 0x42, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x36, + 0x42, 0x38, 0x45, 0x31, 0x32, 0x35, 0x37, 0x34, 0x30, 0x41, 0x34, 0x45, + 0x31, 0x32, 0x45, 0x31, 0x30, 0x35, 0x46, 0x44, 0x36, 0x35, 0x33, 0x34, + 0x30, 0x45, 0x43, 0x33, 0x36, 0x39, 0x37, 0x46, 0x41, 0x34, 0x41, 0x30, + 0x33, 0x35, 0x34, 0x34, 0x30, 0x0a, 0x36, 0x37, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x45, 0x34, 0x41, 0x46, 0x34, 0x42, 0x31, + 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x41, 0x35, + 0x35, 0x34, 0x34, 0x44, 0x34, 0x36, 0x34, 0x30, 0x43, 0x43, 0x42, 0x39, + 0x43, 0x44, 0x44, 0x44, 0x33, 0x31, 0x44, 0x33, 0x34, 0x36, 0x34, 0x30, + 0x42, 0x30, 0x38, 0x32, 0x35, 0x38, 0x42, 0x38, 0x30, 0x39, 0x39, 0x46, + 0x33, 0x34, 0x34, 0x30, 0x0a, 0x36, 0x37, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x43, 0x32, 0x42, 0x45, 0x42, 0x45, 0x39, 0x34, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x46, 0x42, 0x44, + 0x34, 0x35, 0x30, 0x32, 0x30, 0x34, 0x30, 0x34, 0x42, 0x43, 0x34, 0x30, + 0x45, 0x34, 0x42, 0x42, 0x31, 0x34, 0x31, 0x34, 0x31, 0x34, 0x30, 0x42, + 0x36, 0x32, 0x45, 0x41, 0x41, 0x36, 0x44, 0x43, 0x41, 0x44, 0x30, 0x33, + 0x41, 0x34, 0x30, 0x0a, 0x36, 0x37, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x32, 0x38, 0x45, 0x46, 0x44, 0x44, 0x33, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x41, 0x30, 0x42, 0x44, + 0x35, 0x33, 0x33, 0x30, 0x34, 0x30, 0x32, 0x39, 0x35, 0x34, 0x41, 0x41, + 0x37, 0x32, 0x43, 0x45, 0x36, 0x44, 0x33, 0x39, 0x34, 0x30, 0x36, 0x38, + 0x37, 0x41, 0x37, 0x37, 0x37, 0x37, 0x44, 0x31, 0x33, 0x44, 0x33, 0x35, + 0x34, 0x30, 0x0a, 0x36, 0x37, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x45, 0x37, 0x30, 0x33, 0x44, 0x45, 0x33, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, 0x30, 0x39, 0x43, 0x39, 0x37, + 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x45, + 0x32, 0x44, 0x32, 0x46, 0x32, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x31, 0x42, 0x37, 0x31, 0x45, 0x32, 0x34, 0x43, 0x34, + 0x30, 0x31, 0x30, 0x44, 0x32, 0x31, 0x46, 0x33, 0x39, 0x39, 0x32, 0x34, + 0x35, 0x34, 0x42, 0x34, 0x30, 0x33, 0x30, 0x42, 0x38, 0x38, 0x36, 0x43, + 0x36, 0x32, 0x38, 0x32, 0x30, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x36, 0x37, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x36, 0x34, + 0x36, 0x39, 0x42, 0x43, 0x32, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x43, 0x30, 0x38, 0x42, 0x46, 0x32, 0x37, 0x34, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x35, 0x34, 0x41, 0x30, 0x34, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x44, 0x31, + 0x32, 0x36, 0x46, 0x46, 0x34, 0x36, 0x34, 0x30, 0x33, 0x37, 0x36, 0x36, + 0x43, 0x35, 0x44, 0x33, 0x38, 0x33, 0x35, 0x42, 0x34, 0x43, 0x34, 0x30, + 0x37, 0x31, 0x31, 0x42, 0x42, 0x32, 0x34, 0x42, 0x30, 0x32, 0x32, 0x38, + 0x34, 0x43, 0x34, 0x30, 0x0a, 0x36, 0x37, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x38, 0x33, 0x37, 0x38, 0x46, 0x33, 0x30, 0x33, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x35, 0x32, 0x30, + 0x37, 0x37, 0x35, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x34, 0x43, 0x32, 0x46, 0x44, 0x41, 0x33, 0x34, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x44, 0x42, 0x31, 0x31, 0x31, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x36, 0x32, 0x37, + 0x41, 0x30, 0x45, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x32, 0x44, 0x45, 0x39, 0x38, 0x45, 0x31, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x35, 0x43, 0x31, 0x44, 0x45, 0x30, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x36, 0x39, 0x33, + 0x37, 0x41, 0x35, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x38, 0x31, 0x42, 0x32, 0x33, 0x46, 0x30, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x41, 0x46, 0x37, 0x39, 0x34, 0x39, 0x37, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x39, 0x33, 0x45, + 0x35, 0x41, 0x39, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x42, 0x39, 0x37, 0x32, 0x34, 0x33, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x39, 0x41, 0x36, 0x42, 0x32, 0x33, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x38, 0x33, 0x31, + 0x33, 0x37, 0x38, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x36, 0x37, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x30, 0x45, 0x34, 0x34, + 0x35, 0x44, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, + 0x35, 0x31, 0x33, 0x32, 0x34, 0x43, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x36, 0x33, 0x32, 0x46, 0x33, 0x46, 0x34, 0x46, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x42, 0x31, 0x31, 0x33, + 0x34, 0x44, 0x31, 0x46, 0x34, 0x30, 0x0a, 0x36, 0x37, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x33, 0x45, 0x37, 0x30, + 0x44, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x34, + 0x38, 0x43, 0x39, 0x45, 0x38, 0x34, 0x41, 0x34, 0x30, 0x39, 0x46, 0x43, + 0x35, 0x39, 0x44, 0x30, 0x41, 0x30, 0x37, 0x38, 0x32, 0x34, 0x30, 0x34, + 0x30, 0x35, 0x42, 0x39, 0x36, 0x43, 0x44, 0x33, 0x45, 0x41, 0x39, 0x41, + 0x45, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x36, 0x38, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x41, 0x37, 0x32, 0x45, 0x33, 0x45, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x46, 0x43, + 0x37, 0x36, 0x43, 0x34, 0x34, 0x46, 0x34, 0x30, 0x34, 0x39, 0x31, 0x44, + 0x31, 0x42, 0x38, 0x35, 0x46, 0x46, 0x36, 0x33, 0x34, 0x41, 0x34, 0x30, + 0x41, 0x43, 0x41, 0x41, 0x39, 0x41, 0x44, 0x43, 0x39, 0x30, 0x41, 0x43, + 0x33, 0x38, 0x34, 0x30, 0x0a, 0x36, 0x38, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x37, 0x34, 0x45, 0x33, 0x44, 0x33, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x34, 0x41, 0x37, 0x41, + 0x38, 0x32, 0x43, 0x34, 0x31, 0x34, 0x30, 0x33, 0x38, 0x33, 0x35, 0x38, + 0x38, 0x42, 0x45, 0x45, 0x30, 0x35, 0x43, 0x35, 0x33, 0x34, 0x30, 0x36, + 0x33, 0x44, 0x36, 0x30, 0x39, 0x42, 0x44, 0x33, 0x32, 0x39, 0x38, 0x34, + 0x44, 0x34, 0x30, 0x0a, 0x36, 0x38, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x32, 0x36, 0x39, 0x32, 0x35, 0x41, 0x36, 0x35, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x32, 0x38, 0x41, 0x36, + 0x30, 0x43, 0x33, 0x42, 0x34, 0x30, 0x36, 0x30, 0x42, 0x41, 0x34, 0x31, + 0x35, 0x41, 0x45, 0x44, 0x42, 0x37, 0x35, 0x32, 0x34, 0x30, 0x34, 0x39, + 0x31, 0x33, 0x36, 0x44, 0x33, 0x38, 0x30, 0x35, 0x36, 0x30, 0x34, 0x32, + 0x34, 0x30, 0x0a, 0x36, 0x38, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x38, 0x46, 0x35, 0x35, 0x31, 0x30, 0x44, 0x34, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x44, 0x44, 0x38, 0x42, + 0x43, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, 0x31, + 0x42, 0x45, 0x33, 0x34, 0x43, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x38, 0x45, 0x45, 0x34, 0x32, 0x34, 0x37, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x32, 0x31, 0x38, + 0x39, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x35, 0x41, 0x32, 0x35, 0x45, 0x46, 0x30, 0x33, 0x46, 0x0a, 0x36, 0x38, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x39, 0x39, + 0x45, 0x34, 0x44, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x43, 0x42, 0x45, 0x39, 0x44, 0x41, 0x46, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x46, 0x31, 0x37, 0x44, 0x32, 0x36, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, 0x36, 0x37, + 0x31, 0x37, 0x43, 0x35, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x36, 0x38, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x32, 0x33, 0x31, + 0x43, 0x38, 0x41, 0x31, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x34, 0x34, 0x46, 0x31, 0x38, 0x38, 0x42, 0x34, 0x37, 0x34, 0x30, 0x35, + 0x35, 0x35, 0x37, 0x46, 0x41, 0x38, 0x39, 0x38, 0x43, 0x42, 0x39, 0x33, + 0x34, 0x34, 0x30, 0x35, 0x37, 0x44, 0x44, 0x31, 0x43, 0x31, 0x38, 0x41, + 0x30, 0x31, 0x32, 0x34, 0x45, 0x34, 0x30, 0x0a, 0x36, 0x38, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x46, 0x46, 0x41, 0x42, + 0x33, 0x36, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x45, + 0x33, 0x42, 0x36, 0x35, 0x42, 0x43, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x45, 0x45, 0x34, 0x45, 0x41, 0x45, 0x42, 0x35, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x41, 0x39, + 0x33, 0x45, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x36, 0x38, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x45, 0x34, 0x32, 0x43, 0x45, 0x45, + 0x33, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x34, + 0x31, 0x34, 0x38, 0x31, 0x35, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x44, 0x38, 0x33, 0x44, 0x41, 0x45, 0x33, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x35, 0x45, 0x42, 0x31, 0x33, + 0x30, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x36, 0x38, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x45, 0x32, 0x30, 0x33, 0x30, + 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x45, 0x39, + 0x32, 0x42, 0x37, 0x32, 0x35, 0x32, 0x34, 0x30, 0x44, 0x36, 0x30, 0x44, + 0x42, 0x33, 0x36, 0x30, 0x31, 0x31, 0x32, 0x45, 0x34, 0x45, 0x34, 0x30, + 0x30, 0x46, 0x36, 0x42, 0x32, 0x38, 0x35, 0x45, 0x35, 0x46, 0x30, 0x33, + 0x35, 0x32, 0x34, 0x30, 0x0a, 0x36, 0x38, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x37, 0x45, 0x39, 0x39, 0x30, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x43, 0x44, 0x42, 0x45, + 0x42, 0x32, 0x39, 0x34, 0x31, 0x34, 0x30, 0x37, 0x38, 0x35, 0x35, 0x44, + 0x46, 0x44, 0x33, 0x37, 0x33, 0x35, 0x31, 0x33, 0x36, 0x34, 0x30, 0x35, + 0x39, 0x45, 0x35, 0x38, 0x37, 0x35, 0x36, 0x39, 0x33, 0x44, 0x34, 0x34, + 0x46, 0x34, 0x30, 0x0a, 0x36, 0x39, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x37, 0x31, 0x30, 0x46, 0x31, 0x39, 0x34, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x34, 0x37, 0x44, 0x30, + 0x45, 0x42, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x46, 0x43, 0x32, 0x30, 0x45, 0x32, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x38, 0x31, 0x33, 0x44, 0x35, 0x43, 0x39, 0x34, 0x41, + 0x34, 0x30, 0x39, 0x42, 0x37, 0x39, 0x34, 0x34, 0x30, 0x41, 0x39, 0x32, + 0x30, 0x46, 0x34, 0x30, 0x34, 0x30, 0x34, 0x38, 0x33, 0x32, 0x30, 0x35, + 0x30, 0x39, 0x38, 0x41, 0x37, 0x33, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x36, + 0x39, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x37, + 0x44, 0x42, 0x43, 0x42, 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x37, 0x36, 0x42, 0x38, 0x34, 0x45, 0x42, 0x33, + 0x46, 0x39, 0x44, 0x35, 0x30, 0x35, 0x38, 0x33, 0x31, 0x37, 0x38, 0x32, + 0x32, 0x35, 0x31, 0x34, 0x30, 0x38, 0x30, 0x33, 0x37, 0x39, 0x33, 0x42, + 0x35, 0x42, 0x37, 0x43, 0x31, 0x33, 0x46, 0x34, 0x30, 0x0a, 0x36, 0x39, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x35, 0x37, + 0x36, 0x33, 0x30, 0x36, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x46, 0x38, 0x46, 0x36, 0x39, 0x43, 0x34, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x43, 0x46, 0x31, 0x46, 0x31, 0x38, + 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x32, 0x36, 0x31, + 0x44, 0x38, 0x38, 0x36, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x41, 0x41, 0x31, 0x30, 0x32, 0x41, 0x30, 0x35, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x41, 0x37, 0x41, 0x38, 0x39, + 0x31, 0x31, 0x34, 0x30, 0x0a, 0x36, 0x39, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x41, 0x46, 0x39, 0x44, 0x41, 0x45, 0x31, 0x35, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x35, 0x34, 0x30, + 0x34, 0x46, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x38, 0x41, 0x37, 0x32, 0x42, 0x31, 0x35, 0x34, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x34, 0x45, 0x39, 0x38, 0x38, 0x32, 0x32, + 0x31, 0x34, 0x30, 0x33, 0x43, 0x33, 0x35, 0x39, 0x36, 0x45, 0x43, 0x30, + 0x37, 0x30, 0x42, 0x34, 0x44, 0x34, 0x30, 0x46, 0x43, 0x42, 0x41, 0x37, + 0x41, 0x45, 0x42, 0x41, 0x32, 0x30, 0x32, 0x33, 0x35, 0x34, 0x30, 0x0a, + 0x36, 0x39, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, + 0x37, 0x45, 0x43, 0x35, 0x41, 0x42, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x45, 0x37, 0x36, 0x37, 0x44, 0x43, 0x33, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x36, 0x46, 0x41, 0x38, 0x33, + 0x37, 0x38, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, + 0x42, 0x44, 0x41, 0x33, 0x33, 0x39, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x38, 0x36, 0x45, 0x43, 0x36, 0x43, 0x43, 0x34, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x45, 0x39, 0x41, + 0x34, 0x33, 0x30, 0x46, 0x34, 0x30, 0x43, 0x45, 0x36, 0x36, 0x33, 0x32, + 0x43, 0x39, 0x39, 0x46, 0x43, 0x32, 0x35, 0x32, 0x34, 0x30, 0x33, 0x36, + 0x30, 0x46, 0x42, 0x46, 0x41, 0x31, 0x33, 0x31, 0x37, 0x35, 0x34, 0x46, + 0x34, 0x30, 0x0a, 0x36, 0x39, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x34, 0x34, 0x36, 0x30, 0x41, 0x37, 0x31, 0x34, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x32, 0x36, 0x30, 0x30, + 0x38, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x46, + 0x31, 0x37, 0x37, 0x30, 0x34, 0x30, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x36, 0x36, 0x41, 0x38, 0x30, 0x31, 0x42, 0x35, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x31, 0x41, 0x30, 0x32, 0x33, + 0x38, 0x32, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x45, + 0x41, 0x33, 0x32, 0x43, 0x37, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x38, 0x42, 0x34, 0x30, 0x42, 0x33, 0x42, 0x33, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x32, 0x36, 0x35, 0x30, 0x34, + 0x43, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x45, + 0x31, 0x31, 0x42, 0x37, 0x36, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x30, 0x32, 0x39, 0x38, 0x30, 0x32, 0x41, 0x34, 0x35, 0x34, + 0x30, 0x0a, 0x36, 0x39, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x36, 0x30, 0x33, 0x36, 0x32, 0x35, 0x46, 0x35, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x35, 0x45, 0x39, 0x34, 0x37, 0x30, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x39, 0x46, + 0x42, 0x43, 0x39, 0x43, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x44, 0x38, 0x38, 0x35, 0x38, 0x39, 0x36, 0x41, 0x34, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x36, 0x33, 0x42, 0x39, 0x39, 0x45, + 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x32, 0x45, + 0x33, 0x32, 0x46, 0x42, 0x31, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x31, 0x42, 0x36, 0x41, 0x32, 0x31, 0x31, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x32, 0x30, 0x32, 0x33, 0x31, 0x43, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x46, + 0x37, 0x46, 0x43, 0x45, 0x32, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x41, 0x46, 0x45, 0x42, 0x31, 0x45, 0x45, 0x33, 0x46, + 0x0a, 0x36, 0x39, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x33, 0x34, 0x32, 0x39, 0x44, 0x36, 0x32, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x43, 0x46, 0x39, 0x42, 0x33, 0x43, 0x38, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x44, 0x46, 0x31, + 0x45, 0x31, 0x37, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x32, 0x38, 0x33, 0x30, 0x45, 0x36, 0x31, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x30, 0x45, 0x46, 0x44, 0x45, 0x33, 0x35, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x35, + 0x41, 0x31, 0x43, 0x44, 0x34, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x43, 0x36, 0x34, 0x32, 0x44, 0x39, 0x39, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x34, 0x45, 0x30, 0x42, 0x39, 0x41, 0x36, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x37, 0x37, 0x41, + 0x36, 0x32, 0x46, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x30, 0x44, 0x35, 0x31, 0x42, 0x38, 0x35, 0x35, 0x36, 0x34, 0x30, 0x0a, + 0x36, 0x39, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, + 0x46, 0x36, 0x45, 0x44, 0x44, 0x46, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x36, 0x33, 0x46, 0x39, 0x43, 0x41, 0x30, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x44, 0x37, 0x43, + 0x30, 0x35, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x38, 0x35, 0x38, 0x33, 0x39, 0x43, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x41, 0x41, 0x45, 0x35, 0x45, 0x42, 0x30, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x32, 0x39, 0x45, 0x36, + 0x41, 0x38, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x36, 0x39, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x38, 0x34, 0x33, 0x45, 0x30, + 0x39, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x34, + 0x38, 0x37, 0x44, 0x42, 0x46, 0x32, 0x34, 0x34, 0x30, 0x35, 0x30, 0x33, + 0x44, 0x38, 0x44, 0x36, 0x30, 0x32, 0x38, 0x32, 0x34, 0x34, 0x39, 0x34, + 0x30, 0x35, 0x36, 0x41, 0x42, 0x45, 0x43, 0x44, 0x46, 0x34, 0x45, 0x32, + 0x42, 0x34, 0x30, 0x34, 0x30, 0x0a, 0x37, 0x30, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x41, 0x39, 0x30, 0x37, 0x42, 0x37, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x32, 0x32, + 0x39, 0x34, 0x43, 0x33, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x38, 0x35, 0x45, 0x41, 0x35, 0x36, 0x32, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x30, 0x34, 0x32, 0x34, 0x43, 0x42, + 0x35, 0x38, 0x34, 0x30, 0x42, 0x38, 0x34, 0x41, 0x37, 0x33, 0x37, 0x44, + 0x36, 0x41, 0x42, 0x33, 0x34, 0x37, 0x34, 0x30, 0x45, 0x37, 0x36, 0x37, + 0x44, 0x43, 0x42, 0x42, 0x42, 0x30, 0x33, 0x33, 0x35, 0x35, 0x34, 0x30, + 0x0a, 0x37, 0x30, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x32, 0x46, 0x36, 0x31, 0x46, 0x44, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x45, 0x30, 0x30, 0x43, 0x38, 0x38, 0x35, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x37, 0x31, 0x32, + 0x41, 0x34, 0x35, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x43, 0x35, 0x35, 0x35, 0x32, 0x34, 0x44, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x30, 0x31, 0x45, 0x46, 0x34, 0x31, 0x38, 0x32, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x43, 0x43, 0x32, + 0x45, 0x46, 0x34, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x37, 0x30, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x41, 0x31, 0x35, 0x42, + 0x34, 0x30, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x45, 0x38, 0x33, 0x36, 0x36, 0x32, 0x35, 0x38, 0x34, 0x30, 0x45, 0x38, + 0x36, 0x37, 0x42, 0x36, 0x42, 0x30, 0x33, 0x41, 0x32, 0x42, 0x34, 0x32, + 0x34, 0x30, 0x35, 0x31, 0x42, 0x44, 0x46, 0x41, 0x39, 0x46, 0x45, 0x36, + 0x31, 0x39, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x37, 0x30, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x37, 0x30, 0x35, 0x44, 0x35, + 0x41, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, 0x32, + 0x43, 0x46, 0x32, 0x33, 0x37, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x38, 0x33, 0x41, 0x30, 0x36, 0x36, 0x41, 0x33, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x42, 0x41, 0x30, 0x46, + 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x38, + 0x35, 0x35, 0x30, 0x41, 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x41, 0x33, 0x30, 0x39, 0x34, 0x30, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x36, 0x43, 0x36, 0x38, 0x37, + 0x42, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x45, + 0x43, 0x46, 0x35, 0x44, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x43, 0x44, 0x42, 0x46, 0x33, 0x33, 0x39, 0x35, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, 0x46, 0x30, 0x38, 0x36, 0x44, + 0x45, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x37, 0x30, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x39, 0x34, 0x33, 0x30, 0x46, + 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x34, + 0x39, 0x33, 0x33, 0x34, 0x32, 0x32, 0x34, 0x30, 0x38, 0x32, 0x42, 0x44, + 0x38, 0x36, 0x37, 0x34, 0x35, 0x37, 0x39, 0x44, 0x34, 0x44, 0x34, 0x30, + 0x36, 0x41, 0x44, 0x32, 0x46, 0x34, 0x34, 0x35, 0x39, 0x37, 0x38, 0x37, + 0x32, 0x46, 0x34, 0x30, 0x0a, 0x37, 0x30, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x30, 0x42, 0x36, 0x33, 0x36, 0x35, 0x31, 0x30, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x43, 0x42, 0x46, + 0x36, 0x42, 0x39, 0x35, 0x35, 0x34, 0x30, 0x37, 0x34, 0x39, 0x41, 0x41, + 0x44, 0x42, 0x45, 0x31, 0x35, 0x39, 0x41, 0x32, 0x46, 0x34, 0x30, 0x38, + 0x33, 0x39, 0x44, 0x37, 0x46, 0x41, 0x36, 0x43, 0x31, 0x32, 0x46, 0x33, + 0x43, 0x34, 0x30, 0x0a, 0x37, 0x30, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x42, 0x46, 0x34, 0x38, 0x44, 0x37, 0x32, 0x45, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x30, + 0x36, 0x30, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x41, + 0x38, 0x42, 0x33, 0x38, 0x42, 0x42, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x41, 0x38, 0x31, 0x32, 0x43, 0x45, 0x41, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x38, 0x36, 0x33, + 0x41, 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x44, 0x45, 0x36, 0x34, 0x30, 0x30, 0x33, 0x34, 0x34, 0x30, 0x44, 0x38, + 0x33, 0x33, 0x35, 0x34, 0x32, 0x45, 0x30, 0x46, 0x43, 0x30, 0x35, 0x37, + 0x34, 0x30, 0x44, 0x31, 0x42, 0x44, 0x39, 0x44, 0x34, 0x39, 0x45, 0x33, + 0x43, 0x36, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x37, 0x30, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x45, 0x39, 0x34, 0x31, 0x31, 0x39, + 0x44, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x34, + 0x42, 0x35, 0x32, 0x33, 0x46, 0x31, 0x45, 0x34, 0x30, 0x39, 0x45, 0x30, + 0x30, 0x42, 0x33, 0x42, 0x30, 0x46, 0x41, 0x36, 0x39, 0x34, 0x43, 0x34, + 0x30, 0x36, 0x34, 0x44, 0x44, 0x31, 0x38, 0x38, 0x41, 0x42, 0x31, 0x35, + 0x36, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x37, 0x30, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x39, 0x30, 0x46, 0x42, 0x45, 0x41, + 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x30, 0x35, + 0x30, 0x30, 0x46, 0x45, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x43, 0x33, 0x46, 0x42, 0x45, 0x35, 0x42, 0x34, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x34, 0x34, 0x35, 0x36, 0x44, + 0x35, 0x30, 0x34, 0x30, 0x0a, 0x37, 0x30, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x43, 0x36, 0x46, 0x39, 0x30, 0x31, 0x31, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x30, 0x32, + 0x44, 0x39, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x35, 0x46, 0x31, 0x44, 0x34, 0x42, 0x33, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x32, 0x45, 0x39, 0x45, 0x35, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x43, 0x31, 0x46, + 0x33, 0x45, 0x41, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x31, 0x46, 0x43, 0x31, 0x32, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x36, 0x36, 0x32, 0x33, 0x34, 0x30, 0x33, 0x35, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x38, 0x33, + 0x37, 0x42, 0x30, 0x32, 0x36, 0x34, 0x30, 0x0a, 0x37, 0x31, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x41, 0x44, 0x31, 0x32, + 0x36, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x34, 0x34, 0x33, 0x31, 0x41, 0x39, 0x31, 0x41, 0x34, 0x30, 0x39, 0x44, + 0x45, 0x31, 0x45, 0x37, 0x31, 0x33, 0x32, 0x45, 0x39, 0x37, 0x35, 0x35, + 0x34, 0x30, 0x31, 0x45, 0x33, 0x32, 0x42, 0x37, 0x46, 0x30, 0x41, 0x41, + 0x42, 0x41, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x37, 0x31, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x39, 0x45, 0x36, 0x37, + 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, + 0x35, 0x39, 0x45, 0x38, 0x32, 0x34, 0x45, 0x34, 0x30, 0x45, 0x33, 0x41, + 0x32, 0x39, 0x41, 0x41, 0x35, 0x33, 0x39, 0x43, 0x31, 0x34, 0x46, 0x34, + 0x30, 0x34, 0x43, 0x39, 0x43, 0x38, 0x34, 0x32, 0x35, 0x37, 0x39, 0x43, + 0x42, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x37, 0x31, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x45, 0x31, 0x36, 0x39, 0x31, 0x43, 0x46, + 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x42, 0x39, + 0x35, 0x33, 0x39, 0x45, 0x34, 0x34, 0x34, 0x30, 0x34, 0x31, 0x45, 0x31, + 0x41, 0x45, 0x35, 0x39, 0x45, 0x38, 0x35, 0x35, 0x34, 0x30, 0x34, 0x30, + 0x39, 0x43, 0x34, 0x35, 0x33, 0x42, 0x39, 0x33, 0x35, 0x37, 0x32, 0x31, + 0x32, 0x44, 0x34, 0x30, 0x0a, 0x37, 0x31, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x37, 0x42, 0x34, 0x43, 0x45, 0x46, + 0x32, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x39, 0x37, 0x33, + 0x30, 0x43, 0x30, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x41, 0x30, 0x46, 0x44, 0x45, 0x32, 0x34, 0x35, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x43, 0x35, 0x33, 0x41, 0x36, 0x42, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x42, 0x38, 0x41, + 0x39, 0x38, 0x43, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x34, 0x36, 0x42, 0x43, 0x39, 0x30, 0x46, 0x35, 0x34, 0x34, 0x30, 0x0a, + 0x37, 0x31, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x46, 0x38, 0x45, 0x33, 0x37, 0x45, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x43, 0x35, 0x35, 0x44, 0x32, 0x46, 0x42, 0x34, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x39, 0x44, 0x36, 0x41, + 0x44, 0x38, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x34, 0x46, 0x39, 0x45, 0x41, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x32, 0x34, 0x30, 0x31, 0x32, 0x41, 0x32, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x43, 0x33, 0x34, 0x38, + 0x31, 0x32, 0x32, 0x43, 0x34, 0x30, 0x0a, 0x37, 0x31, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, 0x46, 0x34, 0x36, 0x45, + 0x33, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x45, + 0x42, 0x45, 0x35, 0x41, 0x32, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x34, 0x32, 0x42, 0x39, 0x37, 0x35, 0x42, 0x34, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x35, 0x43, 0x31, + 0x33, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x30, + 0x41, 0x41, 0x38, 0x33, 0x44, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x38, 0x32, 0x30, 0x38, 0x35, 0x36, 0x36, 0x34, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x31, 0x30, 0x31, 0x34, 0x36, + 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, + 0x41, 0x38, 0x42, 0x42, 0x35, 0x30, 0x30, 0x34, 0x30, 0x0a, 0x37, 0x31, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x34, 0x35, + 0x36, 0x30, 0x43, 0x39, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x43, 0x31, 0x33, 0x31, 0x36, 0x30, 0x32, 0x35, 0x30, 0x34, 0x30, + 0x45, 0x41, 0x30, 0x35, 0x45, 0x34, 0x38, 0x31, 0x37, 0x30, 0x41, 0x44, + 0x35, 0x34, 0x34, 0x30, 0x42, 0x30, 0x42, 0x37, 0x37, 0x37, 0x39, 0x43, + 0x38, 0x32, 0x46, 0x32, 0x34, 0x41, 0x34, 0x30, 0x0a, 0x37, 0x31, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x36, 0x46, + 0x32, 0x43, 0x39, 0x31, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x38, 0x41, 0x36, 0x31, 0x43, 0x37, 0x44, 0x33, 0x36, 0x34, 0x30, 0x33, + 0x35, 0x31, 0x39, 0x36, 0x42, 0x41, 0x45, 0x35, 0x32, 0x31, 0x42, 0x33, + 0x30, 0x34, 0x30, 0x42, 0x35, 0x37, 0x39, 0x45, 0x33, 0x34, 0x36, 0x33, + 0x39, 0x42, 0x30, 0x34, 0x33, 0x34, 0x30, 0x0a, 0x37, 0x31, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, 0x43, 0x46, 0x33, 0x34, + 0x46, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x45, + 0x43, 0x31, 0x42, 0x36, 0x39, 0x36, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x39, 0x41, 0x33, 0x39, 0x45, 0x37, 0x33, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x39, 0x32, 0x41, + 0x37, 0x37, 0x34, 0x42, 0x34, 0x30, 0x34, 0x45, 0x31, 0x31, 0x36, 0x44, + 0x36, 0x42, 0x38, 0x36, 0x39, 0x30, 0x33, 0x44, 0x34, 0x30, 0x44, 0x43, + 0x44, 0x42, 0x42, 0x46, 0x46, 0x46, 0x42, 0x44, 0x36, 0x35, 0x34, 0x37, + 0x34, 0x30, 0x0a, 0x37, 0x31, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x43, 0x30, 0x31, 0x43, 0x45, 0x41, 0x44, 0x34, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x41, 0x31, 0x34, 0x38, 0x42, + 0x33, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, + 0x33, 0x45, 0x45, 0x41, 0x30, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x36, 0x46, 0x46, 0x34, 0x34, 0x46, 0x38, 0x35, 0x38, 0x34, + 0x30, 0x43, 0x35, 0x43, 0x37, 0x35, 0x45, 0x30, 0x45, 0x46, 0x45, 0x43, + 0x45, 0x34, 0x32, 0x34, 0x30, 0x43, 0x33, 0x43, 0x44, 0x30, 0x34, 0x44, + 0x31, 0x42, 0x41, 0x30, 0x41, 0x34, 0x42, 0x34, 0x30, 0x0a, 0x37, 0x32, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x34, 0x46, + 0x31, 0x46, 0x41, 0x42, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x30, 0x36, 0x33, 0x30, 0x46, 0x44, 0x36, 0x32, 0x31, 0x34, 0x30, + 0x33, 0x43, 0x33, 0x35, 0x45, 0x45, 0x37, 0x34, 0x32, 0x32, 0x44, 0x38, + 0x34, 0x42, 0x34, 0x30, 0x37, 0x30, 0x38, 0x38, 0x44, 0x31, 0x43, 0x43, + 0x39, 0x39, 0x35, 0x42, 0x34, 0x39, 0x34, 0x30, 0x0a, 0x37, 0x32, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x37, 0x37, + 0x33, 0x31, 0x43, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x38, 0x37, 0x45, 0x37, 0x39, 0x33, 0x38, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x38, 0x31, 0x37, 0x36, 0x38, 0x32, 0x35, 0x33, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x32, 0x34, 0x46, + 0x33, 0x44, 0x34, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x34, 0x35, 0x34, 0x35, 0x33, 0x42, 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x35, 0x45, 0x43, 0x43, 0x43, 0x31, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x34, 0x41, + 0x36, 0x33, 0x36, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x33, 0x35, 0x44, 0x38, 0x37, 0x35, 0x35, 0x32, 0x34, 0x30, 0x0a, + 0x37, 0x32, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, + 0x43, 0x43, 0x34, 0x34, 0x43, 0x37, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x34, 0x46, 0x41, 0x41, 0x41, 0x37, 0x39, 0x34, 0x31, + 0x34, 0x30, 0x46, 0x33, 0x37, 0x41, 0x43, 0x31, 0x41, 0x42, 0x34, 0x37, + 0x35, 0x43, 0x34, 0x42, 0x34, 0x30, 0x31, 0x33, 0x30, 0x46, 0x46, 0x46, + 0x36, 0x33, 0x42, 0x30, 0x42, 0x44, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x37, + 0x32, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x32, + 0x38, 0x44, 0x38, 0x35, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x30, 0x33, 0x33, 0x33, 0x31, 0x45, 0x42, 0x33, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x36, 0x33, 0x32, 0x34, 0x41, + 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x34, 0x37, + 0x35, 0x39, 0x44, 0x31, 0x46, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x37, 0x32, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x41, 0x30, + 0x37, 0x37, 0x43, 0x31, 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x30, 0x36, 0x39, 0x42, 0x34, 0x37, 0x37, 0x34, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x45, 0x35, 0x39, 0x33, 0x42, 0x39, 0x35, + 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x33, 0x31, + 0x34, 0x34, 0x31, 0x35, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x38, 0x32, 0x36, 0x42, 0x36, 0x44, 0x34, 0x33, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x31, 0x38, 0x36, 0x44, 0x38, + 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x45, + 0x41, 0x34, 0x41, 0x30, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x45, 0x41, 0x35, 0x42, 0x42, 0x30, 0x31, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x42, 0x37, 0x44, 0x34, 0x46, 0x45, + 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x33, + 0x31, 0x41, 0x31, 0x31, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x37, 0x32, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, 0x36, 0x34, 0x39, + 0x42, 0x46, 0x35, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x34, 0x33, 0x35, 0x33, 0x35, 0x30, 0x37, 0x34, 0x46, 0x34, 0x30, 0x31, + 0x33, 0x31, 0x34, 0x43, 0x44, 0x35, 0x43, 0x44, 0x37, 0x35, 0x39, 0x35, + 0x32, 0x34, 0x30, 0x44, 0x41, 0x45, 0x37, 0x44, 0x44, 0x42, 0x33, 0x39, + 0x39, 0x39, 0x44, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x37, 0x32, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x38, 0x41, 0x32, 0x38, + 0x43, 0x36, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x32, 0x37, 0x31, 0x34, 0x35, 0x45, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x31, 0x44, 0x44, 0x37, 0x34, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x36, 0x43, 0x36, 0x34, 0x37, + 0x32, 0x41, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, + 0x32, 0x41, 0x44, 0x33, 0x42, 0x35, 0x31, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x41, 0x30, 0x45, 0x35, 0x42, 0x45, 0x36, 0x35, 0x30, + 0x34, 0x30, 0x0a, 0x37, 0x32, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x34, 0x35, 0x35, 0x35, 0x46, 0x30, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x30, 0x42, 0x45, 0x33, 0x39, + 0x31, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x31, + 0x32, 0x43, 0x41, 0x37, 0x43, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x42, 0x42, 0x41, 0x39, 0x30, 0x44, 0x34, 0x38, 0x34, + 0x30, 0x35, 0x42, 0x41, 0x41, 0x33, 0x36, 0x36, 0x42, 0x35, 0x39, 0x42, + 0x45, 0x35, 0x32, 0x34, 0x30, 0x42, 0x39, 0x31, 0x37, 0x34, 0x41, 0x31, + 0x35, 0x46, 0x45, 0x41, 0x42, 0x34, 0x39, 0x34, 0x30, 0x0a, 0x37, 0x32, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x43, 0x32, + 0x30, 0x35, 0x41, 0x37, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x38, 0x38, 0x38, 0x38, 0x44, 0x33, 0x42, 0x33, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x45, 0x37, 0x43, 0x43, 0x38, + 0x46, 0x38, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x42, 0x41, + 0x34, 0x30, 0x35, 0x35, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x41, 0x36, 0x31, 0x44, 0x35, 0x37, 0x32, 0x35, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x38, 0x46, 0x46, 0x38, 0x36, 0x36, + 0x35, 0x36, 0x34, 0x30, 0x0a, 0x37, 0x32, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x32, 0x46, 0x38, 0x41, 0x35, 0x46, 0x44, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x45, 0x34, 0x45, 0x43, + 0x43, 0x42, 0x33, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x43, 0x45, 0x44, 0x37, 0x38, 0x46, 0x39, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x41, 0x36, 0x32, 0x45, 0x42, 0x35, 0x33, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x36, 0x33, 0x31, 0x46, + 0x34, 0x33, 0x46, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x43, 0x36, 0x37, 0x36, 0x39, 0x36, 0x34, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x38, 0x39, 0x45, 0x46, 0x45, 0x44, 0x42, 0x33, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x36, 0x33, 0x42, 0x37, + 0x39, 0x39, 0x37, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x37, 0x33, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x45, 0x34, 0x37, + 0x36, 0x31, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x41, 0x30, 0x39, 0x42, 0x42, 0x35, 0x46, 0x30, 0x33, 0x46, 0x35, 0x46, + 0x43, 0x41, 0x32, 0x43, 0x44, 0x41, 0x46, 0x36, 0x32, 0x38, 0x32, 0x32, + 0x34, 0x30, 0x37, 0x34, 0x38, 0x31, 0x43, 0x31, 0x34, 0x44, 0x43, 0x39, + 0x34, 0x46, 0x34, 0x30, 0x34, 0x30, 0x0a, 0x37, 0x33, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x35, 0x37, 0x38, 0x32, 0x42, + 0x36, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x30, + 0x39, 0x35, 0x38, 0x34, 0x46, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x38, 0x30, 0x38, 0x43, 0x32, 0x44, 0x45, 0x33, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x34, 0x38, 0x34, 0x45, 0x42, + 0x36, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, + 0x43, 0x35, 0x44, 0x46, 0x36, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x30, 0x43, 0x38, 0x32, 0x37, 0x30, 0x44, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x32, 0x46, 0x39, 0x32, 0x37, + 0x43, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x41, + 0x35, 0x46, 0x38, 0x38, 0x33, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x37, 0x33, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x34, 0x45, + 0x38, 0x33, 0x34, 0x41, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x34, 0x39, 0x39, 0x39, 0x32, 0x46, 0x36, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x33, 0x46, 0x30, 0x46, 0x37, 0x37, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x44, 0x35, + 0x33, 0x37, 0x36, 0x34, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x38, 0x45, 0x39, 0x30, 0x38, 0x44, 0x33, 0x33, 0x39, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x34, 0x33, 0x46, 0x35, 0x39, 0x35, + 0x34, 0x44, 0x34, 0x30, 0x0a, 0x37, 0x33, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x36, 0x41, 0x45, 0x36, 0x34, 0x33, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x34, 0x39, 0x46, + 0x41, 0x30, 0x31, 0x35, 0x35, 0x34, 0x30, 0x33, 0x32, 0x32, 0x33, 0x33, + 0x39, 0x30, 0x38, 0x41, 0x30, 0x34, 0x35, 0x34, 0x43, 0x34, 0x30, 0x31, + 0x37, 0x46, 0x42, 0x45, 0x42, 0x30, 0x41, 0x34, 0x41, 0x45, 0x30, 0x35, + 0x31, 0x34, 0x30, 0x0a, 0x37, 0x33, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x38, 0x33, 0x44, 0x38, 0x33, 0x35, 0x42, 0x34, 0x43, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x34, 0x30, 0x36, 0x42, + 0x34, 0x39, 0x34, 0x34, 0x34, 0x30, 0x39, 0x45, 0x42, 0x35, 0x31, 0x44, + 0x37, 0x36, 0x37, 0x38, 0x37, 0x37, 0x34, 0x35, 0x34, 0x30, 0x38, 0x41, + 0x46, 0x36, 0x32, 0x42, 0x41, 0x35, 0x32, 0x30, 0x45, 0x41, 0x34, 0x42, + 0x34, 0x30, 0x0a, 0x37, 0x33, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x38, 0x36, 0x44, 0x37, 0x42, 0x37, 0x34, 0x34, 0x41, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, 0x43, 0x38, 0x44, 0x30, + 0x34, 0x32, 0x35, 0x34, 0x30, 0x46, 0x45, 0x42, 0x31, 0x44, 0x46, 0x41, + 0x36, 0x44, 0x42, 0x32, 0x45, 0x35, 0x30, 0x34, 0x30, 0x35, 0x43, 0x39, + 0x43, 0x39, 0x36, 0x35, 0x45, 0x31, 0x41, 0x43, 0x42, 0x33, 0x41, 0x34, + 0x30, 0x0a, 0x37, 0x33, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x39, 0x32, 0x39, 0x30, 0x44, 0x33, 0x32, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x34, 0x45, 0x39, 0x32, 0x30, 0x43, + 0x34, 0x32, 0x34, 0x30, 0x32, 0x35, 0x36, 0x38, 0x39, 0x31, 0x35, 0x46, + 0x36, 0x30, 0x39, 0x36, 0x33, 0x43, 0x34, 0x30, 0x33, 0x34, 0x46, 0x34, + 0x34, 0x34, 0x33, 0x41, 0x38, 0x42, 0x38, 0x30, 0x34, 0x46, 0x34, 0x30, + 0x0a, 0x37, 0x33, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x38, 0x30, 0x41, 0x32, 0x32, 0x42, 0x32, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x38, 0x35, 0x35, 0x34, 0x38, 0x31, 0x46, 0x34, + 0x41, 0x34, 0x30, 0x37, 0x38, 0x35, 0x45, 0x38, 0x35, 0x33, 0x42, 0x36, + 0x30, 0x38, 0x43, 0x32, 0x45, 0x34, 0x30, 0x42, 0x45, 0x43, 0x39, 0x43, + 0x33, 0x44, 0x33, 0x35, 0x36, 0x32, 0x45, 0x34, 0x45, 0x34, 0x30, 0x0a, + 0x37, 0x33, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, + 0x44, 0x35, 0x36, 0x46, 0x44, 0x37, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x34, 0x44, 0x39, 0x44, 0x36, 0x34, 0x33, 0x35, 0x32, + 0x34, 0x30, 0x45, 0x42, 0x41, 0x37, 0x33, 0x31, 0x37, 0x39, 0x46, 0x31, + 0x32, 0x36, 0x35, 0x31, 0x34, 0x30, 0x33, 0x42, 0x31, 0x34, 0x45, 0x33, + 0x33, 0x39, 0x41, 0x42, 0x45, 0x34, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x37, + 0x33, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x45, 0x41, + 0x46, 0x38, 0x36, 0x44, 0x45, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x45, 0x31, 0x35, 0x34, 0x43, 0x31, 0x32, 0x35, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, 0x38, 0x39, 0x30, 0x42, + 0x30, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x46, + 0x46, 0x46, 0x41, 0x45, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x38, 0x38, 0x30, 0x45, 0x30, 0x34, 0x33, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x32, 0x42, 0x37, 0x30, 0x39, + 0x42, 0x34, 0x39, 0x34, 0x30, 0x42, 0x45, 0x33, 0x42, 0x31, 0x32, 0x41, + 0x32, 0x41, 0x45, 0x34, 0x34, 0x34, 0x36, 0x34, 0x30, 0x43, 0x35, 0x46, + 0x39, 0x46, 0x46, 0x33, 0x31, 0x36, 0x41, 0x38, 0x34, 0x34, 0x34, 0x34, + 0x30, 0x0a, 0x37, 0x34, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x32, 0x43, 0x34, 0x32, 0x35, 0x45, 0x42, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x41, 0x32, 0x32, 0x45, 0x30, 0x42, 0x45, + 0x35, 0x30, 0x34, 0x30, 0x36, 0x35, 0x37, 0x31, 0x44, 0x38, 0x42, 0x46, + 0x41, 0x42, 0x36, 0x43, 0x35, 0x35, 0x34, 0x30, 0x46, 0x30, 0x38, 0x30, + 0x43, 0x32, 0x33, 0x35, 0x43, 0x38, 0x44, 0x33, 0x35, 0x30, 0x34, 0x30, + 0x0a, 0x37, 0x34, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x38, 0x38, 0x43, 0x32, 0x33, 0x34, 0x42, 0x33, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x31, 0x43, 0x31, 0x43, 0x42, 0x32, + 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x45, 0x39, 0x39, + 0x34, 0x33, 0x31, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x44, 0x32, 0x45, 0x42, 0x36, 0x43, 0x34, 0x46, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x43, 0x37, 0x39, 0x41, 0x45, 0x33, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x44, 0x39, 0x42, + 0x36, 0x35, 0x38, 0x32, 0x45, 0x34, 0x30, 0x0a, 0x37, 0x34, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, 0x35, 0x39, 0x32, + 0x31, 0x36, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, + 0x38, 0x32, 0x35, 0x46, 0x38, 0x34, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x38, 0x36, 0x36, 0x33, 0x31, 0x34, 0x30, 0x35, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x34, 0x36, 0x46, 0x37, + 0x46, 0x35, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, + 0x37, 0x44, 0x42, 0x38, 0x39, 0x30, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, 0x34, 0x45, 0x46, 0x35, 0x37, + 0x34, 0x30, 0x0a, 0x37, 0x34, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x32, 0x43, 0x33, 0x45, 0x44, 0x45, 0x37, 0x35, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x46, 0x44, 0x34, 0x45, + 0x45, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, + 0x35, 0x39, 0x43, 0x35, 0x32, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x43, 0x45, 0x35, 0x43, 0x44, 0x41, 0x36, 0x35, 0x30, 0x34, + 0x30, 0x0a, 0x37, 0x34, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x31, 0x38, 0x42, 0x36, 0x34, 0x32, 0x35, 0x34, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x46, 0x41, 0x42, 0x37, 0x44, 0x38, + 0x32, 0x42, 0x34, 0x30, 0x31, 0x33, 0x43, 0x36, 0x31, 0x42, 0x34, 0x45, + 0x38, 0x32, 0x33, 0x41, 0x34, 0x45, 0x34, 0x30, 0x42, 0x39, 0x42, 0x34, + 0x31, 0x45, 0x33, 0x44, 0x37, 0x30, 0x46, 0x32, 0x32, 0x38, 0x34, 0x30, + 0x0a, 0x37, 0x34, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x34, 0x34, 0x35, 0x34, 0x42, 0x45, 0x43, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x38, 0x34, 0x38, 0x38, 0x44, + 0x30, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x38, 0x36, 0x46, + 0x44, 0x44, 0x34, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x34, 0x30, 0x44, 0x46, 0x36, 0x35, 0x43, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x41, 0x42, 0x39, 0x35, 0x30, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x32, 0x46, + 0x32, 0x39, 0x46, 0x34, 0x34, 0x34, 0x30, 0x45, 0x36, 0x35, 0x35, 0x45, + 0x46, 0x38, 0x43, 0x32, 0x38, 0x36, 0x38, 0x34, 0x33, 0x34, 0x30, 0x42, + 0x46, 0x38, 0x39, 0x34, 0x45, 0x43, 0x43, 0x45, 0x43, 0x36, 0x46, 0x34, + 0x43, 0x34, 0x30, 0x0a, 0x37, 0x34, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x32, 0x46, 0x30, 0x35, 0x44, 0x30, 0x34, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x33, 0x33, 0x44, 0x37, + 0x43, 0x39, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x32, 0x37, 0x32, 0x39, 0x37, 0x36, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x43, 0x38, 0x37, 0x38, 0x41, 0x45, 0x37, 0x34, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x42, 0x39, 0x32, 0x37, + 0x39, 0x32, 0x33, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x42, 0x34, 0x42, 0x36, 0x36, 0x30, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x37, + 0x34, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x45, + 0x35, 0x43, 0x44, 0x44, 0x32, 0x34, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x43, 0x32, 0x34, 0x30, 0x36, 0x45, 0x37, 0x34, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x35, 0x43, 0x33, 0x32, 0x30, + 0x39, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x43, + 0x31, 0x37, 0x33, 0x34, 0x39, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x43, 0x41, 0x37, 0x44, 0x42, 0x36, 0x33, 0x34, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x43, 0x45, 0x39, 0x31, 0x43, + 0x33, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x43, + 0x41, 0x38, 0x34, 0x36, 0x41, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x42, 0x33, 0x44, 0x36, 0x30, 0x44, 0x34, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x37, 0x41, 0x35, 0x46, 0x31, + 0x46, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, + 0x31, 0x43, 0x35, 0x35, 0x46, 0x31, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x38, 0x33, 0x45, 0x34, 0x35, 0x36, 0x35, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x46, 0x45, 0x39, 0x32, 0x44, + 0x45, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x37, 0x34, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x42, 0x31, 0x32, 0x44, 0x31, 0x38, + 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x39, + 0x44, 0x31, 0x31, 0x36, 0x33, 0x32, 0x34, 0x30, 0x45, 0x43, 0x46, 0x45, + 0x41, 0x44, 0x36, 0x30, 0x39, 0x30, 0x37, 0x38, 0x34, 0x33, 0x34, 0x30, + 0x41, 0x36, 0x34, 0x33, 0x35, 0x46, 0x42, 0x39, 0x45, 0x31, 0x31, 0x34, + 0x33, 0x42, 0x34, 0x30, 0x0a, 0x37, 0x34, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x38, 0x35, 0x36, 0x43, 0x42, 0x30, 0x33, 0x34, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x35, 0x34, 0x35, + 0x39, 0x43, 0x41, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x43, 0x42, 0x43, 0x45, 0x30, 0x36, 0x45, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x30, 0x45, 0x30, 0x43, 0x39, 0x42, 0x34, 0x31, + 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x43, 0x44, 0x42, + 0x38, 0x37, 0x42, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x35, 0x33, 0x43, 0x46, 0x39, 0x42, 0x32, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x46, 0x44, 0x30, 0x43, 0x32, 0x30, 0x34, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x33, 0x41, 0x43, + 0x41, 0x36, 0x46, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x37, 0x35, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x45, 0x34, 0x34, 0x38, + 0x34, 0x35, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x41, 0x32, 0x41, 0x43, 0x42, 0x35, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x43, 0x35, 0x45, 0x45, 0x31, 0x44, 0x32, 0x43, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, 0x33, 0x34, 0x34, 0x35, + 0x43, 0x42, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x45, + 0x31, 0x37, 0x39, 0x41, 0x43, 0x44, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x42, 0x42, 0x38, 0x36, 0x31, 0x32, 0x32, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x30, 0x31, 0x46, 0x46, + 0x32, 0x31, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x39, 0x36, 0x34, 0x45, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x37, 0x37, 0x31, 0x34, 0x41, 0x30, 0x33, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x41, 0x31, 0x43, 0x33, + 0x31, 0x42, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x37, 0x35, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x32, 0x32, 0x35, 0x31, 0x37, + 0x37, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x38, + 0x31, 0x43, 0x31, 0x35, 0x35, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x30, 0x37, 0x44, 0x43, 0x33, 0x39, 0x44, 0x34, 0x46, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x36, 0x34, 0x41, 0x34, 0x42, + 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x45, + 0x43, 0x41, 0x43, 0x32, 0x42, 0x32, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x34, 0x35, 0x44, 0x38, 0x46, 0x46, 0x33, 0x34, 0x46, 0x34, + 0x30, 0x0a, 0x37, 0x35, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x31, 0x31, 0x43, 0x35, 0x44, 0x32, 0x31, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x44, 0x43, 0x36, 0x42, 0x32, 0x33, 0x39, 0x37, + 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, + 0x37, 0x42, 0x44, 0x33, 0x42, 0x30, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x43, 0x39, 0x31, 0x35, 0x30, 0x35, 0x31, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x32, 0x44, 0x31, 0x32, 0x33, 0x32, + 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x33, 0x33, + 0x38, 0x45, 0x43, 0x45, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x38, 0x31, 0x33, 0x32, 0x34, 0x35, 0x45, 0x33, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x36, 0x39, 0x41, 0x42, 0x30, 0x38, + 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, + 0x44, 0x35, 0x31, 0x38, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x38, 0x42, 0x44, 0x30, 0x42, 0x32, 0x43, 0x33, 0x45, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x34, 0x35, 0x43, 0x39, 0x34, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x41, 0x34, + 0x41, 0x36, 0x45, 0x31, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x45, 0x34, 0x44, 0x36, 0x31, 0x45, 0x46, 0x35, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x31, 0x38, 0x41, 0x35, 0x44, 0x39, + 0x35, 0x33, 0x34, 0x30, 0x0a, 0x37, 0x35, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x32, 0x36, 0x31, 0x46, 0x37, 0x33, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x45, 0x34, 0x43, 0x45, + 0x41, 0x41, 0x34, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x32, 0x32, 0x34, 0x30, 0x34, 0x32, 0x45, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x43, 0x46, 0x44, 0x36, 0x46, 0x44, 0x35, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x34, 0x41, + 0x37, 0x44, 0x37, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x30, 0x30, 0x38, 0x35, 0x34, 0x41, 0x38, 0x34, 0x32, 0x34, 0x30, 0x0a, + 0x37, 0x35, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x32, + 0x39, 0x44, 0x43, 0x42, 0x43, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x38, 0x43, 0x34, 0x41, 0x41, 0x34, 0x45, 0x34, 0x43, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x35, 0x41, 0x33, 0x42, + 0x46, 0x32, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, + 0x33, 0x46, 0x31, 0x41, 0x33, 0x33, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x30, 0x38, 0x34, 0x44, 0x43, 0x44, 0x38, 0x33, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x45, 0x46, 0x46, 0x42, + 0x32, 0x44, 0x30, 0x41, 0x34, 0x30, 0x0a, 0x37, 0x35, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x44, 0x30, 0x46, 0x45, 0x45, + 0x46, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x31, + 0x45, 0x30, 0x32, 0x36, 0x43, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x34, 0x30, 0x45, 0x32, 0x46, 0x42, 0x43, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x41, 0x33, 0x42, 0x32, 0x32, 0x38, + 0x37, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x46, + 0x44, 0x33, 0x36, 0x37, 0x30, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x37, 0x32, 0x37, 0x35, 0x34, 0x44, 0x31, 0x36, 0x34, + 0x30, 0x42, 0x41, 0x41, 0x37, 0x38, 0x33, 0x42, 0x37, 0x38, 0x38, 0x36, + 0x36, 0x35, 0x30, 0x34, 0x30, 0x43, 0x36, 0x39, 0x41, 0x34, 0x33, 0x39, + 0x32, 0x30, 0x33, 0x39, 0x30, 0x32, 0x45, 0x34, 0x30, 0x0a, 0x37, 0x35, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, 0x38, + 0x30, 0x34, 0x32, 0x35, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x31, 0x30, 0x39, 0x45, 0x37, 0x34, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x46, 0x45, 0x31, 0x44, 0x34, 0x46, + 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x38, 0x32, + 0x42, 0x32, 0x44, 0x44, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x30, 0x31, 0x31, 0x41, 0x37, 0x46, 0x35, 0x34, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, 0x41, 0x33, 0x42, 0x46, 0x35, + 0x31, 0x33, 0x34, 0x30, 0x0a, 0x37, 0x35, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x30, 0x38, 0x43, 0x46, 0x44, 0x43, 0x45, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x36, 0x32, + 0x33, 0x46, 0x33, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x38, 0x32, 0x46, 0x38, 0x38, 0x43, 0x34, 0x33, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x38, 0x44, 0x45, 0x41, 0x35, 0x45, 0x43, 0x34, + 0x35, 0x34, 0x30, 0x36, 0x33, 0x45, 0x42, 0x31, 0x45, 0x42, 0x34, 0x43, + 0x32, 0x31, 0x32, 0x34, 0x39, 0x34, 0x30, 0x36, 0x45, 0x38, 0x36, 0x44, + 0x30, 0x42, 0x41, 0x42, 0x42, 0x45, 0x39, 0x34, 0x43, 0x34, 0x30, 0x0a, + 0x37, 0x35, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x44, 0x41, 0x38, 0x33, 0x39, 0x37, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x37, 0x32, 0x41, 0x43, 0x38, 0x45, 0x33, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, 0x30, 0x35, 0x31, 0x46, + 0x34, 0x37, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, + 0x33, 0x37, 0x45, 0x31, 0x32, 0x41, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x43, 0x44, 0x46, 0x41, 0x43, 0x30, 0x37, 0x34, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x33, 0x42, 0x34, 0x42, + 0x32, 0x35, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, + 0x35, 0x33, 0x33, 0x31, 0x30, 0x45, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x30, 0x44, 0x45, 0x35, 0x44, 0x41, 0x31, 0x33, 0x30, + 0x34, 0x30, 0x45, 0x39, 0x37, 0x39, 0x31, 0x41, 0x39, 0x41, 0x36, 0x34, + 0x35, 0x32, 0x34, 0x31, 0x34, 0x30, 0x43, 0x34, 0x35, 0x36, 0x46, 0x35, + 0x34, 0x42, 0x42, 0x33, 0x36, 0x33, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x37, + 0x35, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x33, + 0x41, 0x39, 0x31, 0x42, 0x43, 0x33, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x43, 0x35, 0x31, 0x34, 0x37, 0x35, 0x36, 0x34, 0x45, 0x34, + 0x30, 0x42, 0x35, 0x34, 0x34, 0x46, 0x45, 0x35, 0x32, 0x41, 0x46, 0x37, + 0x44, 0x33, 0x43, 0x34, 0x30, 0x44, 0x38, 0x44, 0x37, 0x46, 0x44, 0x31, + 0x39, 0x38, 0x30, 0x42, 0x44, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x37, 0x36, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x36, 0x44, + 0x46, 0x41, 0x46, 0x42, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x33, 0x39, 0x44, 0x45, 0x37, 0x30, 0x34, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x35, 0x38, 0x44, 0x36, + 0x44, 0x42, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x32, 0x44, + 0x44, 0x45, 0x32, 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x38, 0x33, 0x39, 0x31, 0x41, 0x39, 0x43, 0x35, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x42, 0x36, 0x43, 0x42, 0x37, 0x45, + 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x37, 0x42, + 0x39, 0x36, 0x41, 0x45, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x30, 0x34, 0x36, 0x38, 0x35, 0x46, 0x46, 0x32, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x31, 0x45, 0x37, 0x35, 0x34, 0x33, + 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x34, 0x41, + 0x35, 0x45, 0x36, 0x42, 0x34, 0x33, 0x34, 0x30, 0x0a, 0x37, 0x36, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x43, 0x31, 0x42, 0x37, + 0x45, 0x39, 0x45, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x38, 0x33, 0x36, 0x35, 0x36, 0x38, 0x38, 0x34, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x30, 0x41, 0x35, 0x45, 0x36, 0x34, 0x42, 0x32, + 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x32, 0x43, 0x32, + 0x38, 0x43, 0x34, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x35, 0x34, 0x44, 0x37, 0x39, 0x32, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x38, 0x42, 0x39, 0x36, 0x37, 0x33, 0x41, 0x34, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x34, 0x42, 0x38, + 0x31, 0x43, 0x44, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x43, 0x46, 0x38, 0x38, 0x46, 0x33, 0x38, 0x35, 0x35, 0x34, 0x30, 0x0a, + 0x37, 0x36, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, + 0x30, 0x38, 0x42, 0x30, 0x37, 0x35, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x31, 0x36, 0x32, 0x30, 0x39, 0x43, 0x33, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x37, 0x34, 0x34, 0x36, + 0x38, 0x33, 0x33, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, + 0x46, 0x33, 0x41, 0x39, 0x42, 0x33, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x45, 0x42, 0x34, 0x38, 0x39, 0x32, 0x35, 0x34, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x34, 0x37, 0x46, 0x44, 0x42, + 0x35, 0x34, 0x34, 0x41, 0x34, 0x30, 0x0a, 0x37, 0x36, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x33, 0x43, 0x31, 0x43, + 0x44, 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, + 0x43, 0x37, 0x32, 0x37, 0x44, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x34, 0x43, 0x36, 0x46, 0x43, 0x33, 0x34, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x32, 0x43, 0x45, 0x45, 0x31, + 0x42, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, + 0x33, 0x44, 0x39, 0x46, 0x32, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x43, 0x43, 0x32, 0x32, 0x36, 0x31, 0x41, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x38, 0x34, 0x43, 0x34, 0x33, + 0x37, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x37, + 0x32, 0x39, 0x34, 0x45, 0x30, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x43, 0x46, 0x37, 0x38, 0x31, 0x36, 0x43, 0x34, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x33, 0x41, 0x36, 0x37, + 0x32, 0x31, 0x37, 0x34, 0x30, 0x0a, 0x37, 0x36, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x34, 0x39, 0x36, 0x33, 0x41, 0x43, + 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x45, + 0x43, 0x39, 0x33, 0x31, 0x34, 0x38, 0x34, 0x30, 0x43, 0x38, 0x32, 0x32, + 0x39, 0x39, 0x39, 0x37, 0x39, 0x43, 0x46, 0x37, 0x34, 0x38, 0x34, 0x30, + 0x42, 0x30, 0x46, 0x31, 0x42, 0x43, 0x44, 0x33, 0x30, 0x39, 0x33, 0x38, + 0x34, 0x46, 0x34, 0x30, 0x0a, 0x37, 0x36, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x30, 0x36, 0x43, 0x33, 0x38, 0x38, 0x41, 0x30, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x42, 0x34, 0x38, + 0x32, 0x37, 0x31, 0x34, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x36, 0x32, 0x37, 0x35, 0x46, 0x35, 0x39, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x33, 0x38, 0x38, 0x34, 0x36, 0x46, 0x34, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x34, 0x31, 0x44, + 0x33, 0x42, 0x42, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x36, 0x41, 0x42, 0x36, 0x44, 0x38, 0x32, 0x31, 0x34, 0x30, 0x0a, + 0x37, 0x36, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x35, 0x39, 0x36, 0x31, 0x36, 0x38, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x41, 0x39, 0x30, 0x33, 0x44, 0x35, 0x35, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x43, 0x44, 0x37, 0x34, + 0x38, 0x42, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x37, 0x44, 0x31, 0x34, 0x35, 0x33, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x37, + 0x36, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x32, + 0x44, 0x39, 0x46, 0x30, 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x36, 0x37, 0x38, 0x30, 0x31, 0x46, 0x32, 0x35, 0x34, + 0x30, 0x45, 0x44, 0x37, 0x30, 0x36, 0x44, 0x37, 0x44, 0x37, 0x34, 0x39, + 0x42, 0x34, 0x30, 0x34, 0x30, 0x42, 0x32, 0x46, 0x38, 0x31, 0x37, 0x34, + 0x33, 0x35, 0x33, 0x36, 0x30, 0x33, 0x34, 0x34, 0x30, 0x0a, 0x37, 0x36, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x43, 0x42, + 0x30, 0x37, 0x37, 0x41, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x30, 0x30, 0x39, 0x39, 0x41, 0x42, 0x35, 0x34, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x33, 0x46, 0x42, 0x39, 0x38, 0x43, + 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x34, + 0x32, 0x37, 0x30, 0x35, 0x33, 0x46, 0x34, 0x30, 0x36, 0x36, 0x31, 0x44, + 0x33, 0x32, 0x35, 0x38, 0x32, 0x30, 0x36, 0x30, 0x34, 0x44, 0x34, 0x30, + 0x32, 0x46, 0x35, 0x32, 0x33, 0x39, 0x31, 0x33, 0x45, 0x46, 0x39, 0x38, + 0x35, 0x30, 0x34, 0x30, 0x0a, 0x37, 0x36, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x44, 0x30, 0x35, 0x42, 0x39, 0x34, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x43, 0x35, 0x42, 0x41, + 0x34, 0x43, 0x34, 0x34, 0x46, 0x34, 0x30, 0x35, 0x31, 0x35, 0x31, 0x44, + 0x43, 0x45, 0x45, 0x41, 0x41, 0x44, 0x45, 0x34, 0x31, 0x34, 0x30, 0x31, + 0x46, 0x46, 0x45, 0x33, 0x37, 0x42, 0x37, 0x34, 0x34, 0x31, 0x45, 0x34, + 0x44, 0x34, 0x30, 0x0a, 0x37, 0x37, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x43, 0x37, 0x38, 0x43, 0x46, 0x37, 0x33, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x32, 0x43, 0x37, 0x33, + 0x44, 0x31, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, + 0x41, 0x36, 0x31, 0x37, 0x30, 0x46, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x32, 0x37, 0x31, 0x39, 0x43, 0x30, 0x41, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x33, 0x38, 0x34, 0x44, + 0x36, 0x42, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x37, 0x32, 0x41, 0x43, 0x46, 0x30, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x37, + 0x37, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x33, + 0x30, 0x34, 0x32, 0x46, 0x42, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x36, 0x36, 0x42, 0x38, 0x45, 0x31, 0x32, 0x35, 0x37, 0x34, + 0x30, 0x41, 0x34, 0x45, 0x31, 0x32, 0x45, 0x31, 0x30, 0x35, 0x46, 0x44, + 0x36, 0x35, 0x33, 0x34, 0x30, 0x45, 0x43, 0x33, 0x36, 0x39, 0x37, 0x46, + 0x41, 0x34, 0x41, 0x30, 0x33, 0x35, 0x34, 0x34, 0x30, 0x0a, 0x37, 0x37, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x45, 0x34, 0x41, + 0x46, 0x34, 0x42, 0x31, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x41, 0x35, 0x35, 0x34, 0x34, 0x44, 0x34, 0x36, 0x34, 0x30, + 0x43, 0x43, 0x42, 0x39, 0x43, 0x44, 0x44, 0x44, 0x33, 0x31, 0x44, 0x33, + 0x34, 0x36, 0x34, 0x30, 0x42, 0x30, 0x38, 0x32, 0x35, 0x38, 0x42, 0x38, + 0x30, 0x39, 0x39, 0x46, 0x33, 0x34, 0x34, 0x30, 0x0a, 0x37, 0x37, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x43, 0x32, 0x42, 0x45, + 0x42, 0x45, 0x39, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x30, 0x46, 0x42, 0x44, 0x34, 0x35, 0x30, 0x32, 0x30, 0x34, 0x30, 0x34, + 0x42, 0x43, 0x34, 0x30, 0x45, 0x34, 0x42, 0x42, 0x31, 0x34, 0x31, 0x34, + 0x31, 0x34, 0x30, 0x42, 0x36, 0x32, 0x45, 0x41, 0x41, 0x36, 0x44, 0x43, + 0x41, 0x44, 0x30, 0x33, 0x41, 0x34, 0x30, 0x0a, 0x37, 0x37, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x32, 0x38, 0x45, 0x46, + 0x44, 0x44, 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, + 0x41, 0x30, 0x42, 0x44, 0x35, 0x33, 0x33, 0x30, 0x34, 0x30, 0x32, 0x39, + 0x35, 0x34, 0x41, 0x41, 0x37, 0x32, 0x43, 0x45, 0x36, 0x44, 0x33, 0x39, + 0x34, 0x30, 0x36, 0x38, 0x37, 0x41, 0x37, 0x37, 0x37, 0x37, 0x44, 0x31, + 0x33, 0x44, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x37, 0x37, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x45, 0x37, 0x30, 0x33, 0x44, + 0x45, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, 0x30, + 0x39, 0x43, 0x39, 0x37, 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x45, 0x32, 0x44, 0x32, 0x46, 0x32, 0x33, 0x46, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x42, 0x37, 0x31, 0x45, + 0x32, 0x34, 0x43, 0x34, 0x30, 0x31, 0x30, 0x44, 0x32, 0x31, 0x46, 0x33, + 0x39, 0x39, 0x32, 0x34, 0x35, 0x34, 0x42, 0x34, 0x30, 0x33, 0x30, 0x42, + 0x38, 0x38, 0x36, 0x43, 0x36, 0x32, 0x38, 0x32, 0x30, 0x34, 0x43, 0x34, + 0x30, 0x0a, 0x37, 0x37, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x36, 0x34, 0x36, 0x39, 0x42, 0x43, 0x32, 0x34, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x30, 0x38, 0x42, 0x46, 0x32, 0x37, + 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x35, + 0x34, 0x41, 0x30, 0x34, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x43, 0x44, 0x31, 0x32, 0x36, 0x46, 0x46, 0x34, 0x36, 0x34, 0x30, + 0x33, 0x37, 0x36, 0x36, 0x43, 0x35, 0x44, 0x33, 0x38, 0x33, 0x35, 0x42, + 0x34, 0x43, 0x34, 0x30, 0x37, 0x31, 0x31, 0x42, 0x42, 0x32, 0x34, 0x42, + 0x30, 0x32, 0x32, 0x38, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x37, 0x37, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x33, 0x37, 0x38, + 0x46, 0x33, 0x30, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x38, 0x35, 0x32, 0x30, 0x37, 0x37, 0x35, 0x33, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x34, 0x43, 0x32, 0x46, 0x44, 0x41, 0x33, 0x34, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x44, 0x42, + 0x31, 0x31, 0x31, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x36, 0x36, 0x32, 0x37, 0x41, 0x30, 0x45, 0x35, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x32, 0x44, 0x45, 0x39, 0x38, 0x45, 0x31, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x35, 0x43, + 0x31, 0x44, 0x45, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x36, 0x39, 0x33, 0x37, 0x41, 0x35, 0x33, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x31, 0x42, 0x32, 0x33, 0x46, 0x30, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x41, 0x46, 0x37, 0x39, + 0x34, 0x39, 0x37, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x30, 0x39, 0x33, 0x45, 0x35, 0x41, 0x39, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x42, 0x39, 0x37, 0x32, 0x34, 0x33, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x39, 0x41, + 0x36, 0x42, 0x32, 0x33, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x43, 0x38, 0x33, 0x31, 0x33, 0x37, 0x38, 0x35, 0x38, 0x34, 0x30, 0x0a, + 0x37, 0x37, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, + 0x30, 0x45, 0x34, 0x34, 0x35, 0x44, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x34, 0x35, 0x31, 0x33, 0x32, 0x34, 0x43, 0x34, 0x32, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x36, 0x33, 0x32, 0x46, + 0x33, 0x46, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x42, 0x31, 0x31, 0x33, 0x34, 0x44, 0x31, 0x46, 0x34, 0x30, 0x0a, 0x37, + 0x37, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x33, 0x45, 0x37, 0x30, 0x44, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x38, 0x34, 0x38, 0x43, 0x39, 0x45, 0x38, 0x34, 0x41, 0x34, + 0x30, 0x39, 0x46, 0x43, 0x35, 0x39, 0x44, 0x30, 0x41, 0x30, 0x37, 0x38, + 0x32, 0x34, 0x30, 0x34, 0x30, 0x35, 0x42, 0x39, 0x36, 0x43, 0x44, 0x33, + 0x45, 0x41, 0x39, 0x41, 0x45, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x37, 0x38, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x41, 0x37, + 0x32, 0x45, 0x33, 0x45, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x34, 0x46, 0x43, 0x37, 0x36, 0x43, 0x34, 0x34, 0x46, 0x34, 0x30, + 0x34, 0x39, 0x31, 0x44, 0x31, 0x42, 0x38, 0x35, 0x46, 0x46, 0x36, 0x33, + 0x34, 0x41, 0x34, 0x30, 0x41, 0x43, 0x41, 0x41, 0x39, 0x41, 0x44, 0x43, + 0x39, 0x30, 0x41, 0x43, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x37, 0x38, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x37, 0x34, + 0x45, 0x33, 0x44, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x34, 0x41, 0x37, 0x41, 0x38, 0x32, 0x43, 0x34, 0x31, 0x34, 0x30, 0x33, + 0x38, 0x33, 0x35, 0x38, 0x38, 0x42, 0x45, 0x45, 0x30, 0x35, 0x43, 0x35, + 0x33, 0x34, 0x30, 0x36, 0x33, 0x44, 0x36, 0x30, 0x39, 0x42, 0x44, 0x33, + 0x32, 0x39, 0x38, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x37, 0x38, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x36, 0x39, 0x32, 0x35, + 0x41, 0x36, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, + 0x32, 0x38, 0x41, 0x36, 0x30, 0x43, 0x33, 0x42, 0x34, 0x30, 0x36, 0x30, + 0x42, 0x41, 0x34, 0x31, 0x35, 0x41, 0x45, 0x44, 0x42, 0x37, 0x35, 0x32, + 0x34, 0x30, 0x34, 0x39, 0x31, 0x33, 0x36, 0x44, 0x33, 0x38, 0x30, 0x35, + 0x36, 0x30, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x37, 0x38, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x46, 0x35, 0x35, 0x31, 0x30, + 0x44, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, + 0x44, 0x44, 0x38, 0x42, 0x43, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x36, 0x31, 0x42, 0x45, 0x33, 0x34, 0x43, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x45, 0x45, 0x34, 0x32, 0x34, + 0x37, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x30, 0x32, 0x31, 0x38, 0x39, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x35, 0x41, 0x32, 0x35, 0x45, 0x46, 0x30, 0x33, + 0x46, 0x0a, 0x37, 0x38, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x34, 0x39, 0x39, 0x45, 0x34, 0x44, 0x33, 0x35, 0x34, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x42, 0x45, 0x39, 0x44, 0x41, 0x46, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x46, 0x31, + 0x37, 0x44, 0x32, 0x36, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x43, 0x36, 0x37, 0x31, 0x37, 0x43, 0x35, 0x34, 0x37, 0x34, 0x30, + 0x0a, 0x37, 0x38, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x32, 0x33, 0x31, 0x43, 0x38, 0x41, 0x31, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x34, 0x34, 0x46, 0x31, 0x38, 0x38, 0x42, 0x34, + 0x37, 0x34, 0x30, 0x35, 0x35, 0x35, 0x37, 0x46, 0x41, 0x38, 0x39, 0x38, + 0x43, 0x42, 0x39, 0x33, 0x34, 0x34, 0x30, 0x35, 0x37, 0x44, 0x44, 0x31, + 0x43, 0x31, 0x38, 0x41, 0x30, 0x31, 0x32, 0x34, 0x45, 0x34, 0x30, 0x0a, + 0x37, 0x38, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, + 0x46, 0x46, 0x41, 0x42, 0x33, 0x36, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x45, 0x33, 0x42, 0x36, 0x35, 0x42, 0x43, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x45, 0x45, 0x34, 0x45, 0x41, + 0x45, 0x42, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, + 0x31, 0x35, 0x41, 0x39, 0x33, 0x45, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x37, + 0x38, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x45, 0x34, + 0x32, 0x43, 0x45, 0x45, 0x33, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x38, 0x34, 0x31, 0x34, 0x38, 0x31, 0x35, 0x33, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x44, 0x38, 0x33, 0x44, 0x41, + 0x45, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x35, + 0x45, 0x42, 0x31, 0x33, 0x30, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x37, 0x38, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x45, + 0x32, 0x30, 0x33, 0x30, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x38, 0x45, 0x39, 0x32, 0x42, 0x37, 0x32, 0x35, 0x32, 0x34, 0x30, + 0x44, 0x36, 0x30, 0x44, 0x42, 0x33, 0x36, 0x30, 0x31, 0x31, 0x32, 0x45, + 0x34, 0x45, 0x34, 0x30, 0x30, 0x46, 0x36, 0x42, 0x32, 0x38, 0x35, 0x45, + 0x35, 0x46, 0x30, 0x33, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x37, 0x38, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x37, + 0x45, 0x39, 0x39, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x43, 0x44, 0x42, 0x45, 0x42, 0x32, 0x39, 0x34, 0x31, 0x34, 0x30, 0x37, + 0x38, 0x35, 0x35, 0x44, 0x46, 0x44, 0x33, 0x37, 0x33, 0x35, 0x31, 0x33, + 0x36, 0x34, 0x30, 0x35, 0x39, 0x45, 0x35, 0x38, 0x37, 0x35, 0x36, 0x39, + 0x33, 0x44, 0x34, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x37, 0x39, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x37, 0x31, 0x30, 0x46, + 0x31, 0x39, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, + 0x34, 0x37, 0x44, 0x30, 0x45, 0x42, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x46, 0x43, 0x32, 0x30, 0x45, 0x32, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x33, 0x44, 0x35, + 0x43, 0x39, 0x34, 0x41, 0x34, 0x30, 0x39, 0x42, 0x37, 0x39, 0x34, 0x34, + 0x30, 0x41, 0x39, 0x32, 0x30, 0x46, 0x34, 0x30, 0x34, 0x30, 0x34, 0x38, + 0x33, 0x32, 0x30, 0x35, 0x30, 0x39, 0x38, 0x41, 0x37, 0x33, 0x34, 0x31, + 0x34, 0x30, 0x0a, 0x37, 0x39, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x45, 0x37, 0x44, 0x42, 0x43, 0x42, 0x33, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x37, 0x36, 0x42, 0x38, + 0x34, 0x45, 0x42, 0x33, 0x46, 0x39, 0x44, 0x35, 0x30, 0x35, 0x38, 0x33, + 0x31, 0x37, 0x38, 0x32, 0x32, 0x35, 0x31, 0x34, 0x30, 0x38, 0x30, 0x33, + 0x37, 0x39, 0x33, 0x42, 0x35, 0x42, 0x37, 0x43, 0x31, 0x33, 0x46, 0x34, + 0x30, 0x0a, 0x37, 0x39, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x30, 0x35, 0x37, 0x36, 0x33, 0x30, 0x36, 0x33, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x46, 0x38, 0x46, 0x36, 0x39, 0x43, + 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x43, 0x46, + 0x31, 0x46, 0x31, 0x38, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x32, 0x36, 0x31, 0x44, 0x38, 0x38, 0x36, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x41, 0x31, 0x30, 0x32, 0x41, 0x30, + 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x41, + 0x37, 0x41, 0x38, 0x39, 0x31, 0x31, 0x34, 0x30, 0x0a, 0x37, 0x39, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x46, 0x39, 0x44, + 0x41, 0x45, 0x31, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x38, 0x35, 0x34, 0x30, 0x34, 0x46, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x38, 0x41, 0x37, 0x32, 0x42, 0x31, 0x35, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x34, 0x45, 0x39, + 0x38, 0x38, 0x32, 0x32, 0x31, 0x34, 0x30, 0x33, 0x43, 0x33, 0x35, 0x39, + 0x36, 0x45, 0x43, 0x30, 0x37, 0x30, 0x42, 0x34, 0x44, 0x34, 0x30, 0x46, + 0x43, 0x42, 0x41, 0x37, 0x41, 0x45, 0x42, 0x41, 0x32, 0x30, 0x32, 0x33, + 0x35, 0x34, 0x30, 0x0a, 0x37, 0x39, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x37, 0x45, 0x43, 0x35, 0x41, 0x42, 0x34, 0x45, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x37, 0x36, 0x37, + 0x44, 0x43, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x36, + 0x46, 0x41, 0x38, 0x33, 0x37, 0x38, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x38, 0x42, 0x44, 0x41, 0x33, 0x33, 0x39, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x36, 0x45, 0x43, 0x36, + 0x43, 0x43, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x31, 0x45, 0x39, 0x41, 0x34, 0x33, 0x30, 0x46, 0x34, 0x30, 0x43, 0x45, + 0x36, 0x36, 0x33, 0x32, 0x43, 0x39, 0x39, 0x46, 0x43, 0x32, 0x35, 0x32, + 0x34, 0x30, 0x33, 0x36, 0x30, 0x46, 0x42, 0x46, 0x41, 0x31, 0x33, 0x31, + 0x37, 0x35, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x37, 0x39, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x34, 0x36, 0x30, 0x41, 0x37, + 0x31, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, + 0x32, 0x36, 0x30, 0x30, 0x38, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x30, 0x46, 0x31, 0x37, 0x37, 0x30, 0x34, 0x30, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x36, 0x41, 0x38, 0x30, 0x31, + 0x42, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x31, + 0x41, 0x30, 0x32, 0x33, 0x38, 0x32, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x34, 0x45, 0x41, 0x33, 0x32, 0x43, 0x37, 0x34, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x42, 0x34, 0x30, 0x42, 0x33, + 0x42, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x32, + 0x36, 0x35, 0x30, 0x34, 0x43, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x45, 0x31, 0x31, 0x42, 0x37, 0x36, 0x34, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x32, 0x39, 0x38, 0x30, 0x32, + 0x41, 0x34, 0x35, 0x34, 0x30, 0x0a, 0x37, 0x39, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x33, 0x36, 0x32, 0x35, 0x46, + 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x35, 0x45, + 0x39, 0x34, 0x37, 0x30, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x44, 0x30, 0x39, 0x46, 0x42, 0x43, 0x39, 0x43, 0x33, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x38, 0x35, 0x38, 0x39, 0x36, 0x41, + 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x36, 0x33, + 0x42, 0x39, 0x39, 0x45, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x32, 0x45, 0x33, 0x32, 0x46, 0x42, 0x31, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x42, 0x36, 0x41, 0x32, 0x31, + 0x31, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x32, 0x30, + 0x32, 0x33, 0x31, 0x43, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x46, 0x37, 0x46, 0x43, 0x45, 0x32, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x46, 0x45, 0x42, 0x31, + 0x45, 0x45, 0x33, 0x46, 0x0a, 0x37, 0x39, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x33, 0x34, 0x32, 0x39, 0x44, 0x36, 0x32, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, 0x46, 0x39, 0x42, + 0x33, 0x43, 0x38, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x34, 0x44, 0x46, 0x31, 0x45, 0x31, 0x37, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x38, 0x33, 0x30, 0x45, 0x36, 0x31, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x45, 0x46, 0x44, + 0x45, 0x33, 0x35, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x35, 0x41, 0x31, 0x43, 0x44, 0x34, 0x33, 0x46, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x43, 0x36, 0x34, 0x32, 0x44, 0x39, 0x39, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x34, 0x45, 0x30, 0x42, + 0x39, 0x41, 0x36, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x37, 0x37, 0x41, 0x36, 0x32, 0x46, 0x34, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x30, 0x44, 0x35, 0x31, 0x42, 0x38, 0x35, 0x35, + 0x36, 0x34, 0x30, 0x0a, 0x37, 0x39, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x38, 0x46, 0x36, 0x45, 0x44, 0x44, 0x46, 0x34, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, 0x33, 0x46, 0x39, 0x43, + 0x41, 0x30, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x44, 0x37, 0x43, 0x30, 0x35, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x38, 0x33, 0x39, 0x43, 0x32, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x41, 0x41, 0x45, 0x35, + 0x45, 0x42, 0x30, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, + 0x32, 0x39, 0x45, 0x36, 0x41, 0x38, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x37, + 0x39, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x38, + 0x34, 0x33, 0x45, 0x30, 0x39, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x30, 0x34, 0x38, 0x37, 0x44, 0x42, 0x46, 0x32, 0x34, 0x34, + 0x30, 0x35, 0x30, 0x33, 0x44, 0x38, 0x44, 0x36, 0x30, 0x32, 0x38, 0x32, + 0x34, 0x34, 0x39, 0x34, 0x30, 0x35, 0x36, 0x41, 0x42, 0x45, 0x43, 0x44, + 0x46, 0x34, 0x45, 0x32, 0x42, 0x34, 0x30, 0x34, 0x30, 0x0a, 0x38, 0x30, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x41, 0x39, + 0x30, 0x37, 0x42, 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x38, 0x32, 0x32, 0x39, 0x34, 0x43, 0x33, 0x34, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x35, 0x45, 0x41, 0x35, 0x36, 0x32, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x30, 0x34, + 0x32, 0x34, 0x43, 0x42, 0x35, 0x38, 0x34, 0x30, 0x42, 0x38, 0x34, 0x41, + 0x37, 0x33, 0x37, 0x44, 0x36, 0x41, 0x42, 0x33, 0x34, 0x37, 0x34, 0x30, + 0x45, 0x37, 0x36, 0x37, 0x44, 0x43, 0x42, 0x42, 0x42, 0x30, 0x33, 0x33, + 0x35, 0x35, 0x34, 0x30, 0x0a, 0x38, 0x30, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x32, 0x46, 0x36, 0x31, 0x46, 0x44, 0x32, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x45, 0x30, 0x30, 0x43, + 0x38, 0x38, 0x35, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x41, 0x37, 0x31, 0x32, 0x41, 0x34, 0x35, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x43, 0x35, 0x35, 0x35, 0x32, 0x34, 0x44, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x31, 0x45, 0x46, + 0x34, 0x31, 0x38, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x32, 0x43, 0x43, 0x32, 0x45, 0x46, 0x34, 0x35, 0x31, 0x34, 0x30, 0x0a, + 0x38, 0x30, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x41, 0x31, 0x35, 0x42, 0x34, 0x30, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x45, 0x38, 0x33, 0x36, 0x36, 0x32, 0x35, 0x38, + 0x34, 0x30, 0x45, 0x38, 0x36, 0x37, 0x42, 0x36, 0x42, 0x30, 0x33, 0x41, + 0x32, 0x42, 0x34, 0x32, 0x34, 0x30, 0x35, 0x31, 0x42, 0x44, 0x46, 0x41, + 0x39, 0x46, 0x45, 0x36, 0x31, 0x39, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x38, + 0x30, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x37, + 0x30, 0x35, 0x44, 0x35, 0x41, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x43, 0x32, 0x43, 0x46, 0x32, 0x33, 0x37, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, 0x41, 0x30, 0x36, 0x36, + 0x41, 0x33, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, + 0x42, 0x41, 0x30, 0x46, 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x34, 0x38, 0x35, 0x35, 0x30, 0x41, 0x39, 0x35, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x41, 0x33, 0x30, 0x39, + 0x34, 0x30, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x36, + 0x43, 0x36, 0x38, 0x37, 0x42, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x43, 0x45, 0x43, 0x46, 0x35, 0x44, 0x43, 0x34, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x44, 0x42, 0x46, 0x33, 0x33, + 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, 0x46, + 0x30, 0x38, 0x36, 0x44, 0x45, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x38, 0x30, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x39, + 0x34, 0x33, 0x30, 0x46, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x34, 0x39, 0x33, 0x33, 0x34, 0x32, 0x32, 0x34, 0x30, + 0x38, 0x32, 0x42, 0x44, 0x38, 0x36, 0x37, 0x34, 0x35, 0x37, 0x39, 0x44, + 0x34, 0x44, 0x34, 0x30, 0x36, 0x41, 0x44, 0x32, 0x46, 0x34, 0x34, 0x35, + 0x39, 0x37, 0x38, 0x37, 0x32, 0x46, 0x34, 0x30, 0x0a, 0x38, 0x30, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x42, 0x36, 0x33, + 0x36, 0x35, 0x31, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x38, 0x43, 0x42, 0x46, 0x36, 0x42, 0x39, 0x35, 0x35, 0x34, 0x30, 0x37, + 0x34, 0x39, 0x41, 0x41, 0x44, 0x42, 0x45, 0x31, 0x35, 0x39, 0x41, 0x32, + 0x46, 0x34, 0x30, 0x38, 0x33, 0x39, 0x44, 0x37, 0x46, 0x41, 0x36, 0x43, + 0x31, 0x32, 0x46, 0x33, 0x43, 0x34, 0x30, 0x0a, 0x38, 0x30, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x42, 0x46, 0x34, 0x38, + 0x44, 0x37, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x34, 0x44, 0x30, 0x36, 0x30, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x41, 0x38, 0x42, 0x33, 0x38, 0x42, 0x42, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, 0x38, 0x31, 0x32, 0x43, + 0x45, 0x41, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, + 0x35, 0x38, 0x36, 0x33, 0x41, 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x44, 0x45, 0x36, 0x34, 0x30, 0x30, 0x33, 0x34, + 0x34, 0x30, 0x44, 0x38, 0x33, 0x33, 0x35, 0x34, 0x32, 0x45, 0x30, 0x46, + 0x43, 0x30, 0x35, 0x37, 0x34, 0x30, 0x44, 0x31, 0x42, 0x44, 0x39, 0x44, + 0x34, 0x39, 0x45, 0x33, 0x43, 0x36, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x38, + 0x30, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x45, 0x39, + 0x34, 0x31, 0x31, 0x39, 0x44, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x34, 0x42, 0x35, 0x32, 0x33, 0x46, 0x31, 0x45, 0x34, + 0x30, 0x39, 0x45, 0x30, 0x30, 0x42, 0x33, 0x42, 0x30, 0x46, 0x41, 0x36, + 0x39, 0x34, 0x43, 0x34, 0x30, 0x36, 0x34, 0x44, 0x44, 0x31, 0x38, 0x38, + 0x41, 0x42, 0x31, 0x35, 0x36, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x38, 0x30, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x39, 0x30, + 0x46, 0x42, 0x45, 0x41, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x43, 0x30, 0x35, 0x30, 0x30, 0x46, 0x45, 0x34, 0x44, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x33, 0x46, 0x42, 0x45, 0x35, 0x42, + 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x34, + 0x34, 0x35, 0x36, 0x44, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x38, 0x30, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x36, 0x46, 0x39, + 0x30, 0x31, 0x31, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x30, 0x31, 0x30, 0x32, 0x44, 0x39, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x35, 0x46, 0x31, 0x44, 0x34, 0x42, 0x33, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x32, 0x45, + 0x39, 0x45, 0x35, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x38, 0x43, 0x31, 0x46, 0x33, 0x45, 0x41, 0x34, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x46, 0x43, 0x31, 0x32, 0x35, 0x34, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x36, 0x36, 0x32, 0x33, + 0x34, 0x30, 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x30, 0x30, 0x38, 0x33, 0x37, 0x42, 0x30, 0x32, 0x36, 0x34, 0x30, 0x0a, + 0x38, 0x31, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, + 0x41, 0x44, 0x31, 0x32, 0x36, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x34, 0x34, 0x33, 0x31, 0x41, 0x39, 0x31, 0x41, + 0x34, 0x30, 0x39, 0x44, 0x45, 0x31, 0x45, 0x37, 0x31, 0x33, 0x32, 0x45, + 0x39, 0x37, 0x35, 0x35, 0x34, 0x30, 0x31, 0x45, 0x33, 0x32, 0x42, 0x37, + 0x46, 0x30, 0x41, 0x41, 0x42, 0x41, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x38, + 0x31, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, + 0x39, 0x45, 0x36, 0x37, 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x39, 0x35, 0x39, 0x45, 0x38, 0x32, 0x34, 0x45, 0x34, + 0x30, 0x45, 0x33, 0x41, 0x32, 0x39, 0x41, 0x41, 0x35, 0x33, 0x39, 0x43, + 0x31, 0x34, 0x46, 0x34, 0x30, 0x34, 0x43, 0x39, 0x43, 0x38, 0x34, 0x32, + 0x35, 0x37, 0x39, 0x43, 0x42, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x38, 0x31, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x45, 0x31, 0x36, + 0x39, 0x31, 0x43, 0x46, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x43, 0x42, 0x39, 0x35, 0x33, 0x39, 0x45, 0x34, 0x34, 0x34, 0x30, + 0x34, 0x31, 0x45, 0x31, 0x41, 0x45, 0x35, 0x39, 0x45, 0x38, 0x35, 0x35, + 0x34, 0x30, 0x34, 0x30, 0x39, 0x43, 0x34, 0x35, 0x33, 0x42, 0x39, 0x33, + 0x35, 0x37, 0x32, 0x31, 0x32, 0x44, 0x34, 0x30, 0x0a, 0x38, 0x31, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x37, 0x42, + 0x34, 0x43, 0x45, 0x46, 0x32, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x43, 0x39, 0x37, 0x33, 0x30, 0x43, 0x30, 0x34, 0x44, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x41, 0x30, 0x46, 0x44, 0x45, 0x32, 0x34, 0x35, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x43, 0x35, 0x33, + 0x41, 0x36, 0x42, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x38, 0x42, 0x38, 0x41, 0x39, 0x38, 0x43, 0x34, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x34, 0x36, 0x42, 0x43, 0x39, 0x30, 0x46, 0x35, + 0x34, 0x34, 0x30, 0x0a, 0x38, 0x31, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x46, 0x38, 0x45, 0x33, 0x37, 0x45, 0x34, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x35, 0x35, 0x44, 0x32, + 0x46, 0x42, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, + 0x39, 0x44, 0x36, 0x41, 0x44, 0x38, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x34, 0x46, 0x39, 0x45, 0x41, 0x35, 0x34, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x32, 0x34, 0x30, 0x31, 0x32, + 0x41, 0x32, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, + 0x43, 0x33, 0x34, 0x38, 0x31, 0x32, 0x32, 0x43, 0x34, 0x30, 0x0a, 0x38, + 0x31, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, + 0x46, 0x34, 0x36, 0x45, 0x33, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x45, 0x42, 0x45, 0x35, 0x41, 0x32, 0x34, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x32, 0x42, 0x39, 0x37, 0x35, + 0x42, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x35, 0x43, 0x31, 0x33, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x45, 0x30, 0x41, 0x41, 0x38, 0x33, 0x44, 0x35, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x32, 0x30, 0x38, 0x35, 0x36, + 0x36, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x31, + 0x30, 0x31, 0x34, 0x36, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x36, 0x41, 0x38, 0x42, 0x42, 0x35, 0x30, 0x30, 0x34, + 0x30, 0x0a, 0x38, 0x31, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x32, 0x34, 0x35, 0x36, 0x30, 0x43, 0x39, 0x35, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x31, 0x33, 0x31, 0x36, 0x30, 0x32, + 0x35, 0x30, 0x34, 0x30, 0x45, 0x41, 0x30, 0x35, 0x45, 0x34, 0x38, 0x31, + 0x37, 0x30, 0x41, 0x44, 0x35, 0x34, 0x34, 0x30, 0x42, 0x30, 0x42, 0x37, + 0x37, 0x37, 0x39, 0x43, 0x38, 0x32, 0x46, 0x32, 0x34, 0x41, 0x34, 0x30, + 0x0a, 0x38, 0x31, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x33, 0x36, 0x46, 0x32, 0x43, 0x39, 0x31, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x38, 0x41, 0x36, 0x31, 0x43, 0x37, 0x44, 0x33, + 0x36, 0x34, 0x30, 0x33, 0x35, 0x31, 0x39, 0x36, 0x42, 0x41, 0x45, 0x35, + 0x32, 0x31, 0x42, 0x33, 0x30, 0x34, 0x30, 0x42, 0x35, 0x37, 0x39, 0x45, + 0x33, 0x34, 0x36, 0x33, 0x39, 0x42, 0x30, 0x34, 0x33, 0x34, 0x30, 0x0a, + 0x38, 0x31, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, + 0x43, 0x46, 0x33, 0x34, 0x46, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x45, 0x43, 0x31, 0x42, 0x36, 0x39, 0x36, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x39, 0x41, 0x33, 0x39, + 0x45, 0x37, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x32, 0x39, 0x32, 0x41, 0x37, 0x37, 0x34, 0x42, 0x34, 0x30, 0x34, 0x45, + 0x31, 0x31, 0x36, 0x44, 0x36, 0x42, 0x38, 0x36, 0x39, 0x30, 0x33, 0x44, + 0x34, 0x30, 0x44, 0x43, 0x44, 0x42, 0x42, 0x46, 0x46, 0x46, 0x42, 0x44, + 0x36, 0x35, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x38, 0x31, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x30, 0x31, 0x43, 0x45, 0x41, + 0x44, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x41, + 0x31, 0x34, 0x38, 0x42, 0x33, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x45, 0x33, 0x45, 0x45, 0x41, 0x30, 0x34, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x46, 0x46, 0x34, 0x34, 0x46, + 0x38, 0x35, 0x38, 0x34, 0x30, 0x43, 0x35, 0x43, 0x37, 0x35, 0x45, 0x30, + 0x45, 0x46, 0x45, 0x43, 0x45, 0x34, 0x32, 0x34, 0x30, 0x43, 0x33, 0x43, + 0x44, 0x30, 0x34, 0x44, 0x31, 0x42, 0x41, 0x30, 0x41, 0x34, 0x42, 0x34, + 0x30, 0x0a, 0x38, 0x32, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x38, 0x34, 0x46, 0x31, 0x46, 0x41, 0x42, 0x33, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x36, 0x33, 0x30, 0x46, 0x44, 0x36, + 0x32, 0x31, 0x34, 0x30, 0x33, 0x43, 0x33, 0x35, 0x45, 0x45, 0x37, 0x34, + 0x32, 0x32, 0x44, 0x38, 0x34, 0x42, 0x34, 0x30, 0x37, 0x30, 0x38, 0x38, + 0x44, 0x31, 0x43, 0x43, 0x39, 0x39, 0x35, 0x42, 0x34, 0x39, 0x34, 0x30, + 0x0a, 0x38, 0x32, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x30, 0x37, 0x37, 0x33, 0x31, 0x43, 0x34, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x38, 0x37, 0x45, 0x37, 0x39, 0x33, 0x38, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x31, 0x37, 0x36, + 0x38, 0x32, 0x35, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x32, 0x32, 0x34, 0x46, 0x33, 0x44, 0x34, 0x35, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x34, 0x35, 0x33, 0x42, 0x39, 0x35, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x35, 0x45, 0x43, + 0x43, 0x43, 0x31, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x32, 0x34, 0x41, 0x36, 0x33, 0x36, 0x34, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x35, 0x44, 0x38, 0x37, 0x35, 0x35, + 0x32, 0x34, 0x30, 0x0a, 0x38, 0x32, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x38, 0x43, 0x43, 0x34, 0x34, 0x43, 0x37, 0x34, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x34, 0x46, 0x41, 0x41, 0x41, + 0x37, 0x39, 0x34, 0x31, 0x34, 0x30, 0x46, 0x33, 0x37, 0x41, 0x43, 0x31, + 0x41, 0x42, 0x34, 0x37, 0x35, 0x43, 0x34, 0x42, 0x34, 0x30, 0x31, 0x33, + 0x30, 0x46, 0x46, 0x46, 0x36, 0x33, 0x42, 0x30, 0x42, 0x44, 0x34, 0x31, + 0x34, 0x30, 0x0a, 0x38, 0x32, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x41, 0x32, 0x38, 0x44, 0x38, 0x35, 0x33, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x33, 0x33, 0x33, 0x31, 0x45, + 0x42, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x36, + 0x33, 0x32, 0x34, 0x41, 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x34, 0x37, 0x35, 0x39, 0x44, 0x31, 0x46, 0x35, 0x38, 0x34, + 0x30, 0x0a, 0x38, 0x32, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x38, 0x41, 0x30, 0x37, 0x37, 0x43, 0x31, 0x33, 0x45, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x36, 0x39, 0x42, 0x34, 0x37, 0x37, + 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x45, 0x35, 0x39, + 0x33, 0x42, 0x39, 0x35, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x30, 0x33, 0x31, 0x34, 0x34, 0x31, 0x35, 0x33, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x32, 0x36, 0x42, 0x36, 0x44, 0x34, + 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x31, + 0x38, 0x36, 0x44, 0x38, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x31, 0x45, 0x41, 0x34, 0x41, 0x30, 0x35, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x45, 0x41, 0x35, 0x42, 0x42, 0x30, + 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x42, 0x37, + 0x44, 0x34, 0x46, 0x45, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x38, 0x31, 0x33, 0x31, 0x41, 0x31, 0x31, 0x33, 0x38, 0x34, 0x30, + 0x0a, 0x38, 0x32, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x36, 0x36, 0x34, 0x39, 0x42, 0x46, 0x35, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x34, 0x33, 0x35, 0x33, 0x35, 0x30, 0x37, 0x34, + 0x46, 0x34, 0x30, 0x31, 0x33, 0x31, 0x34, 0x43, 0x44, 0x35, 0x43, 0x44, + 0x37, 0x35, 0x39, 0x35, 0x32, 0x34, 0x30, 0x44, 0x41, 0x45, 0x37, 0x44, + 0x44, 0x42, 0x33, 0x39, 0x39, 0x39, 0x44, 0x35, 0x31, 0x34, 0x30, 0x0a, + 0x38, 0x32, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x38, 0x41, 0x32, 0x38, 0x43, 0x36, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x32, 0x37, 0x31, 0x34, 0x35, 0x45, 0x33, 0x39, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x31, 0x44, + 0x44, 0x37, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x36, + 0x43, 0x36, 0x34, 0x37, 0x32, 0x41, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x30, 0x32, 0x41, 0x44, 0x33, 0x42, 0x35, 0x31, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, 0x30, 0x45, 0x35, 0x42, + 0x45, 0x36, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x38, 0x32, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x35, 0x35, 0x35, + 0x46, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x30, + 0x42, 0x45, 0x33, 0x39, 0x31, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x30, 0x31, 0x32, 0x43, 0x41, 0x37, 0x43, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x42, 0x42, 0x41, 0x39, 0x30, + 0x44, 0x34, 0x38, 0x34, 0x30, 0x35, 0x42, 0x41, 0x41, 0x33, 0x36, 0x36, + 0x42, 0x35, 0x39, 0x42, 0x45, 0x35, 0x32, 0x34, 0x30, 0x42, 0x39, 0x31, + 0x37, 0x34, 0x41, 0x31, 0x35, 0x46, 0x45, 0x41, 0x42, 0x34, 0x39, 0x34, + 0x30, 0x0a, 0x38, 0x32, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x30, 0x43, 0x32, 0x30, 0x35, 0x41, 0x37, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x38, 0x38, 0x38, 0x44, 0x33, 0x42, + 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x45, + 0x37, 0x43, 0x43, 0x38, 0x46, 0x38, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x34, 0x42, 0x41, 0x34, 0x30, 0x35, 0x35, 0x34, 0x43, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x41, 0x36, 0x31, 0x44, 0x35, 0x37, 0x32, + 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x38, 0x46, + 0x46, 0x38, 0x36, 0x36, 0x35, 0x36, 0x34, 0x30, 0x0a, 0x38, 0x32, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x32, 0x46, 0x38, 0x41, + 0x35, 0x46, 0x44, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x45, 0x34, 0x45, 0x43, 0x43, 0x42, 0x33, 0x35, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x43, 0x45, 0x44, 0x37, 0x38, 0x46, 0x39, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x41, 0x36, 0x32, 0x45, + 0x42, 0x35, 0x33, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x36, 0x33, 0x31, 0x46, 0x34, 0x33, 0x46, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x43, 0x36, 0x37, 0x36, 0x39, 0x36, 0x34, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x39, 0x45, 0x46, + 0x45, 0x44, 0x42, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x36, 0x33, 0x42, 0x37, 0x39, 0x39, 0x37, 0x35, 0x37, 0x34, 0x30, 0x0a, + 0x38, 0x33, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, + 0x36, 0x45, 0x34, 0x37, 0x36, 0x31, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x41, 0x30, 0x39, 0x42, 0x42, 0x35, 0x46, 0x30, + 0x33, 0x46, 0x35, 0x46, 0x43, 0x41, 0x32, 0x43, 0x44, 0x41, 0x46, 0x36, + 0x32, 0x38, 0x32, 0x32, 0x34, 0x30, 0x37, 0x34, 0x38, 0x31, 0x43, 0x31, + 0x34, 0x44, 0x43, 0x39, 0x34, 0x46, 0x34, 0x30, 0x34, 0x30, 0x0a, 0x38, + 0x33, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x35, + 0x37, 0x38, 0x32, 0x42, 0x36, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x36, 0x30, 0x39, 0x35, 0x38, 0x34, 0x46, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x30, 0x38, 0x43, 0x32, 0x44, + 0x45, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x34, + 0x38, 0x34, 0x45, 0x42, 0x36, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x43, 0x43, 0x35, 0x44, 0x46, 0x36, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x43, 0x38, 0x32, 0x37, 0x30, + 0x44, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x32, + 0x46, 0x39, 0x32, 0x37, 0x43, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x41, 0x35, 0x46, 0x38, 0x38, 0x33, 0x33, 0x38, 0x34, + 0x30, 0x0a, 0x38, 0x33, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x34, 0x34, 0x45, 0x38, 0x33, 0x34, 0x41, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x39, 0x39, 0x39, 0x32, 0x46, 0x36, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x33, 0x46, + 0x30, 0x46, 0x37, 0x37, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x30, 0x44, 0x35, 0x33, 0x37, 0x36, 0x34, 0x33, 0x39, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x45, 0x39, 0x30, 0x38, 0x44, 0x33, + 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x34, 0x33, + 0x46, 0x35, 0x39, 0x35, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x38, 0x33, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x36, 0x41, + 0x45, 0x36, 0x34, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x32, 0x34, 0x39, 0x46, 0x41, 0x30, 0x31, 0x35, 0x35, 0x34, 0x30, 0x33, + 0x32, 0x32, 0x33, 0x33, 0x39, 0x30, 0x38, 0x41, 0x30, 0x34, 0x35, 0x34, + 0x43, 0x34, 0x30, 0x31, 0x37, 0x46, 0x42, 0x45, 0x42, 0x30, 0x41, 0x34, + 0x41, 0x45, 0x30, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x38, 0x33, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x33, 0x44, 0x38, 0x33, + 0x35, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, + 0x34, 0x30, 0x36, 0x42, 0x34, 0x39, 0x34, 0x34, 0x34, 0x30, 0x39, 0x45, + 0x42, 0x35, 0x31, 0x44, 0x37, 0x36, 0x37, 0x38, 0x37, 0x37, 0x34, 0x35, + 0x34, 0x30, 0x38, 0x41, 0x46, 0x36, 0x32, 0x42, 0x41, 0x35, 0x32, 0x30, + 0x45, 0x41, 0x34, 0x42, 0x34, 0x30, 0x0a, 0x38, 0x33, 0x35, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x36, 0x44, 0x37, 0x42, 0x37, + 0x34, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, + 0x43, 0x38, 0x44, 0x30, 0x34, 0x32, 0x35, 0x34, 0x30, 0x46, 0x45, 0x42, + 0x31, 0x44, 0x46, 0x41, 0x36, 0x44, 0x42, 0x32, 0x45, 0x35, 0x30, 0x34, + 0x30, 0x35, 0x43, 0x39, 0x43, 0x39, 0x36, 0x35, 0x45, 0x31, 0x41, 0x43, + 0x42, 0x33, 0x41, 0x34, 0x30, 0x0a, 0x38, 0x33, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x32, 0x39, 0x30, 0x44, 0x33, + 0x32, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x34, 0x45, + 0x39, 0x32, 0x30, 0x43, 0x34, 0x32, 0x34, 0x30, 0x32, 0x35, 0x36, 0x38, + 0x39, 0x31, 0x35, 0x46, 0x36, 0x30, 0x39, 0x36, 0x33, 0x43, 0x34, 0x30, + 0x33, 0x34, 0x46, 0x34, 0x34, 0x34, 0x33, 0x41, 0x38, 0x42, 0x38, 0x30, + 0x34, 0x46, 0x34, 0x30, 0x0a, 0x38, 0x33, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x38, 0x30, 0x41, 0x32, 0x32, 0x42, 0x32, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x35, 0x35, 0x34, + 0x38, 0x31, 0x46, 0x34, 0x41, 0x34, 0x30, 0x37, 0x38, 0x35, 0x45, 0x38, + 0x35, 0x33, 0x42, 0x36, 0x30, 0x38, 0x43, 0x32, 0x45, 0x34, 0x30, 0x42, + 0x45, 0x43, 0x39, 0x43, 0x33, 0x44, 0x33, 0x35, 0x36, 0x32, 0x45, 0x34, + 0x45, 0x34, 0x30, 0x0a, 0x38, 0x33, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x34, 0x44, 0x35, 0x36, 0x46, 0x44, 0x37, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x39, 0x44, 0x36, + 0x34, 0x33, 0x35, 0x32, 0x34, 0x30, 0x45, 0x42, 0x41, 0x37, 0x33, 0x31, + 0x37, 0x39, 0x46, 0x31, 0x32, 0x36, 0x35, 0x31, 0x34, 0x30, 0x33, 0x42, + 0x31, 0x34, 0x45, 0x33, 0x33, 0x39, 0x41, 0x42, 0x45, 0x34, 0x35, 0x33, + 0x34, 0x30, 0x0a, 0x38, 0x33, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x45, 0x41, 0x46, 0x38, 0x36, 0x44, 0x45, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x45, 0x31, 0x35, 0x34, 0x43, 0x31, + 0x32, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, + 0x38, 0x39, 0x30, 0x42, 0x30, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x34, 0x46, 0x46, 0x46, 0x41, 0x45, 0x33, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x38, 0x30, 0x45, 0x30, 0x34, + 0x33, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x32, + 0x42, 0x37, 0x30, 0x39, 0x42, 0x34, 0x39, 0x34, 0x30, 0x42, 0x45, 0x33, + 0x42, 0x31, 0x32, 0x41, 0x32, 0x41, 0x45, 0x34, 0x34, 0x34, 0x36, 0x34, + 0x30, 0x43, 0x35, 0x46, 0x39, 0x46, 0x46, 0x33, 0x31, 0x36, 0x41, 0x38, + 0x34, 0x34, 0x34, 0x34, 0x30, 0x0a, 0x38, 0x34, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x32, 0x43, 0x34, 0x32, 0x35, 0x45, 0x42, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x41, 0x32, 0x32, + 0x45, 0x30, 0x42, 0x45, 0x35, 0x30, 0x34, 0x30, 0x36, 0x35, 0x37, 0x31, + 0x44, 0x38, 0x42, 0x46, 0x41, 0x42, 0x36, 0x43, 0x35, 0x35, 0x34, 0x30, + 0x46, 0x30, 0x38, 0x30, 0x43, 0x32, 0x33, 0x35, 0x43, 0x38, 0x44, 0x33, + 0x35, 0x30, 0x34, 0x30, 0x0a, 0x38, 0x34, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x38, 0x38, 0x43, 0x32, 0x33, 0x34, 0x42, 0x33, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x31, 0x43, + 0x31, 0x43, 0x42, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x45, 0x45, 0x39, 0x39, 0x34, 0x33, 0x31, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x44, 0x32, 0x45, 0x42, 0x36, 0x43, 0x34, + 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x43, 0x37, + 0x39, 0x41, 0x45, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x30, 0x44, 0x39, 0x42, 0x36, 0x35, 0x38, 0x32, 0x45, 0x34, 0x30, 0x0a, + 0x38, 0x34, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x43, 0x35, 0x39, 0x32, 0x31, 0x36, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x42, 0x38, 0x38, 0x32, 0x35, 0x46, 0x38, 0x34, 0x34, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x36, 0x36, 0x33, 0x31, + 0x34, 0x30, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, + 0x34, 0x36, 0x46, 0x37, 0x46, 0x35, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x32, 0x37, 0x44, 0x42, 0x38, 0x39, 0x30, 0x35, 0x33, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, 0x34, + 0x45, 0x46, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x38, 0x34, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x43, 0x33, 0x45, 0x44, 0x45, + 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, + 0x46, 0x44, 0x34, 0x45, 0x45, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x30, 0x32, 0x35, 0x39, 0x43, 0x35, 0x32, 0x32, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x45, 0x35, 0x43, 0x44, 0x41, + 0x36, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x38, 0x34, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x38, 0x42, 0x36, 0x34, 0x32, + 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x46, 0x41, + 0x42, 0x37, 0x44, 0x38, 0x32, 0x42, 0x34, 0x30, 0x31, 0x33, 0x43, 0x36, + 0x31, 0x42, 0x34, 0x45, 0x38, 0x32, 0x33, 0x41, 0x34, 0x45, 0x34, 0x30, + 0x42, 0x39, 0x42, 0x34, 0x31, 0x45, 0x33, 0x44, 0x37, 0x30, 0x46, 0x32, + 0x32, 0x38, 0x34, 0x30, 0x0a, 0x38, 0x34, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x34, 0x34, 0x35, 0x34, 0x42, 0x45, 0x43, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x38, + 0x34, 0x38, 0x38, 0x44, 0x30, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x36, 0x38, 0x36, 0x46, 0x44, 0x44, 0x34, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x44, 0x46, 0x36, 0x35, 0x43, 0x34, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x41, 0x42, + 0x39, 0x35, 0x30, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x34, 0x35, 0x32, 0x46, 0x32, 0x39, 0x46, 0x34, 0x34, 0x34, 0x30, 0x45, + 0x36, 0x35, 0x35, 0x45, 0x46, 0x38, 0x43, 0x32, 0x38, 0x36, 0x38, 0x34, + 0x33, 0x34, 0x30, 0x42, 0x46, 0x38, 0x39, 0x34, 0x45, 0x43, 0x43, 0x45, + 0x43, 0x36, 0x46, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x38, 0x34, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x46, 0x30, 0x35, + 0x44, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, + 0x33, 0x33, 0x44, 0x37, 0x43, 0x39, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x32, 0x37, 0x32, 0x39, 0x37, 0x36, 0x31, 0x32, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x38, 0x37, 0x38, 0x41, + 0x45, 0x37, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x42, 0x39, 0x32, 0x37, 0x39, 0x32, 0x33, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x42, 0x34, 0x42, 0x36, 0x36, 0x30, 0x35, 0x30, + 0x34, 0x30, 0x0a, 0x38, 0x34, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x45, 0x35, 0x43, 0x44, 0x44, 0x32, 0x34, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x32, 0x34, 0x30, 0x36, 0x45, + 0x37, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x35, + 0x43, 0x33, 0x32, 0x30, 0x39, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x43, 0x43, 0x31, 0x37, 0x33, 0x34, 0x39, 0x34, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x41, 0x37, 0x44, 0x42, 0x36, + 0x33, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x43, + 0x45, 0x39, 0x31, 0x43, 0x33, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x43, 0x41, 0x38, 0x34, 0x36, 0x41, 0x34, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x42, 0x33, 0x44, 0x36, 0x30, + 0x44, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x37, + 0x41, 0x35, 0x46, 0x31, 0x46, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x30, 0x31, 0x43, 0x35, 0x35, 0x46, 0x31, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x33, 0x45, 0x34, 0x35, + 0x36, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x46, + 0x45, 0x39, 0x32, 0x44, 0x45, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x38, 0x34, + 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x42, 0x31, + 0x32, 0x44, 0x31, 0x38, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x30, 0x31, 0x39, 0x44, 0x31, 0x31, 0x36, 0x33, 0x32, 0x34, 0x30, + 0x45, 0x43, 0x46, 0x45, 0x41, 0x44, 0x36, 0x30, 0x39, 0x30, 0x37, 0x38, + 0x34, 0x33, 0x34, 0x30, 0x41, 0x36, 0x34, 0x33, 0x35, 0x46, 0x42, 0x39, + 0x45, 0x31, 0x31, 0x34, 0x33, 0x42, 0x34, 0x30, 0x0a, 0x38, 0x34, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x35, 0x36, 0x43, + 0x42, 0x30, 0x33, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x34, 0x35, 0x34, 0x35, 0x39, 0x43, 0x41, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x43, 0x42, 0x43, 0x45, 0x30, 0x36, 0x45, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x45, 0x30, 0x43, + 0x39, 0x42, 0x34, 0x31, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x43, 0x44, 0x42, 0x38, 0x37, 0x42, 0x34, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x33, 0x43, 0x46, 0x39, 0x42, 0x32, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x46, 0x44, 0x30, + 0x43, 0x32, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x32, 0x33, 0x41, 0x43, 0x41, 0x36, 0x46, 0x35, 0x33, 0x34, 0x30, 0x0a, + 0x38, 0x35, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x45, 0x34, 0x34, 0x38, 0x34, 0x35, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x41, 0x32, 0x41, 0x43, 0x42, 0x35, 0x32, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x43, 0x35, 0x45, 0x45, + 0x31, 0x44, 0x32, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, + 0x33, 0x34, 0x34, 0x35, 0x43, 0x42, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x45, 0x31, 0x37, 0x39, 0x41, 0x43, 0x44, 0x35, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x42, 0x42, 0x38, 0x36, + 0x31, 0x32, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, + 0x30, 0x31, 0x46, 0x46, 0x32, 0x31, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x39, 0x36, 0x34, 0x45, 0x33, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x37, 0x37, 0x31, 0x34, + 0x41, 0x30, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x41, 0x31, 0x43, 0x33, 0x31, 0x42, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x38, + 0x35, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x32, + 0x32, 0x35, 0x31, 0x37, 0x37, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x41, 0x38, 0x31, 0x43, 0x31, 0x35, 0x35, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x37, 0x44, 0x43, 0x33, 0x39, + 0x44, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x36, + 0x34, 0x41, 0x34, 0x42, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x45, 0x43, 0x41, 0x43, 0x32, 0x42, 0x32, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x35, 0x44, 0x38, 0x46, 0x46, + 0x33, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x38, 0x35, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, 0x31, 0x43, 0x35, 0x44, 0x32, + 0x31, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x43, 0x36, 0x42, + 0x32, 0x33, 0x39, 0x37, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x30, 0x37, 0x42, 0x44, 0x33, 0x42, 0x30, 0x33, 0x46, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x39, 0x31, 0x35, 0x30, 0x35, 0x31, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x32, 0x44, + 0x31, 0x32, 0x33, 0x32, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x43, 0x33, 0x33, 0x38, 0x45, 0x43, 0x45, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x31, 0x33, 0x32, 0x34, 0x35, 0x45, + 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x36, 0x39, + 0x41, 0x42, 0x30, 0x38, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x34, 0x44, 0x35, 0x31, 0x38, 0x34, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x42, 0x44, 0x30, 0x42, 0x32, 0x43, + 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x34, + 0x35, 0x43, 0x39, 0x34, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x41, 0x34, 0x41, 0x36, 0x45, 0x31, 0x32, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x34, 0x44, 0x36, 0x31, 0x45, 0x46, + 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x31, 0x38, + 0x41, 0x35, 0x44, 0x39, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x38, 0x35, 0x33, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x32, 0x36, 0x31, + 0x46, 0x37, 0x33, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x45, 0x34, 0x43, 0x45, 0x41, 0x41, 0x34, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x32, 0x32, 0x34, 0x30, 0x34, 0x32, + 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x43, 0x46, 0x44, 0x36, + 0x46, 0x44, 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x33, 0x34, 0x41, 0x37, 0x44, 0x37, 0x33, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x38, 0x35, 0x34, 0x41, 0x38, 0x34, + 0x32, 0x34, 0x30, 0x0a, 0x38, 0x35, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x32, 0x39, 0x44, 0x43, 0x42, 0x43, 0x33, 0x35, 0x34, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x43, 0x34, 0x41, 0x41, + 0x34, 0x45, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, + 0x35, 0x41, 0x33, 0x42, 0x46, 0x32, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x38, 0x33, 0x46, 0x31, 0x41, 0x33, 0x33, 0x34, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x38, 0x34, 0x44, 0x43, + 0x44, 0x38, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x45, 0x46, 0x46, 0x42, 0x32, 0x44, 0x30, 0x41, 0x34, 0x30, 0x0a, 0x38, + 0x35, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x44, + 0x30, 0x46, 0x45, 0x45, 0x46, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x43, 0x30, 0x31, 0x45, 0x30, 0x32, 0x36, 0x43, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x30, 0x45, 0x32, 0x46, 0x42, + 0x43, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x41, 0x33, + 0x42, 0x32, 0x32, 0x38, 0x37, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x38, 0x46, 0x44, 0x33, 0x36, 0x37, 0x30, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x32, 0x37, 0x35, 0x34, + 0x44, 0x31, 0x36, 0x34, 0x30, 0x42, 0x41, 0x41, 0x37, 0x38, 0x33, 0x42, + 0x37, 0x38, 0x38, 0x36, 0x36, 0x35, 0x30, 0x34, 0x30, 0x43, 0x36, 0x39, + 0x41, 0x34, 0x33, 0x39, 0x32, 0x30, 0x33, 0x39, 0x30, 0x32, 0x45, 0x34, + 0x30, 0x0a, 0x38, 0x35, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x30, 0x41, 0x38, 0x30, 0x34, 0x32, 0x35, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, 0x39, 0x45, 0x37, 0x34, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x46, 0x45, + 0x31, 0x44, 0x34, 0x46, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x38, 0x38, 0x32, 0x42, 0x32, 0x44, 0x44, 0x33, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x31, 0x41, 0x37, 0x46, 0x35, + 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, 0x41, + 0x33, 0x42, 0x46, 0x35, 0x31, 0x33, 0x34, 0x30, 0x0a, 0x38, 0x35, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x38, 0x43, 0x46, + 0x44, 0x43, 0x45, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x36, 0x36, 0x32, 0x33, 0x46, 0x33, 0x33, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x38, 0x32, 0x46, 0x38, 0x38, 0x43, 0x34, 0x33, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x44, 0x45, 0x41, + 0x35, 0x45, 0x43, 0x34, 0x35, 0x34, 0x30, 0x36, 0x33, 0x45, 0x42, 0x31, + 0x45, 0x42, 0x34, 0x43, 0x32, 0x31, 0x32, 0x34, 0x39, 0x34, 0x30, 0x36, + 0x45, 0x38, 0x36, 0x44, 0x30, 0x42, 0x41, 0x42, 0x42, 0x45, 0x39, 0x34, + 0x43, 0x34, 0x30, 0x0a, 0x38, 0x35, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x44, 0x41, 0x38, 0x33, 0x39, 0x37, 0x33, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x37, 0x32, 0x41, 0x43, + 0x38, 0x45, 0x33, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, + 0x30, 0x35, 0x31, 0x46, 0x34, 0x37, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x33, 0x37, 0x45, 0x31, 0x32, 0x41, 0x33, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, 0x44, 0x46, 0x41, 0x43, + 0x30, 0x37, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x33, 0x42, 0x34, 0x42, 0x32, 0x35, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x43, 0x35, 0x33, 0x33, 0x31, 0x30, 0x45, 0x34, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x44, 0x45, 0x35, 0x44, + 0x41, 0x31, 0x33, 0x30, 0x34, 0x30, 0x45, 0x39, 0x37, 0x39, 0x31, 0x41, + 0x39, 0x41, 0x36, 0x34, 0x35, 0x32, 0x34, 0x31, 0x34, 0x30, 0x43, 0x34, + 0x35, 0x36, 0x46, 0x35, 0x34, 0x42, 0x42, 0x33, 0x36, 0x33, 0x34, 0x32, + 0x34, 0x30, 0x0a, 0x38, 0x35, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x30, 0x33, 0x41, 0x39, 0x31, 0x42, 0x43, 0x33, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x35, 0x31, 0x34, 0x37, 0x35, + 0x36, 0x34, 0x45, 0x34, 0x30, 0x42, 0x35, 0x34, 0x34, 0x46, 0x45, 0x35, + 0x32, 0x41, 0x46, 0x37, 0x44, 0x33, 0x43, 0x34, 0x30, 0x44, 0x38, 0x44, + 0x37, 0x46, 0x44, 0x31, 0x39, 0x38, 0x30, 0x42, 0x44, 0x34, 0x44, 0x34, + 0x30, 0x0a, 0x38, 0x36, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x38, 0x36, 0x44, 0x46, 0x41, 0x46, 0x42, 0x34, 0x42, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x33, 0x39, 0x44, 0x45, 0x37, 0x30, + 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, + 0x35, 0x38, 0x44, 0x36, 0x44, 0x42, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x34, 0x32, 0x44, 0x44, 0x45, 0x32, 0x33, 0x35, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x33, 0x39, 0x31, 0x41, 0x39, 0x43, + 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x42, 0x36, + 0x43, 0x42, 0x37, 0x45, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x38, 0x37, 0x42, 0x39, 0x36, 0x41, 0x45, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x34, 0x36, 0x38, 0x35, 0x46, 0x46, + 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x31, 0x45, + 0x37, 0x35, 0x34, 0x33, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x43, 0x34, 0x41, 0x35, 0x45, 0x36, 0x42, 0x34, 0x33, 0x34, 0x30, + 0x0a, 0x38, 0x36, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x43, 0x31, 0x42, 0x37, 0x45, 0x39, 0x45, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x38, 0x33, 0x36, 0x35, 0x36, 0x38, 0x38, 0x34, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x41, 0x35, 0x45, + 0x36, 0x34, 0x42, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x41, 0x32, 0x43, 0x32, 0x38, 0x43, 0x34, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x44, 0x37, 0x39, 0x32, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x42, 0x39, 0x36, + 0x37, 0x33, 0x41, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x38, 0x34, 0x42, 0x38, 0x31, 0x43, 0x44, 0x33, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x43, 0x46, 0x38, 0x38, 0x46, 0x33, 0x38, 0x35, + 0x35, 0x34, 0x30, 0x0a, 0x38, 0x36, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x38, 0x30, 0x38, 0x42, 0x30, 0x37, 0x35, 0x33, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x36, 0x32, 0x30, + 0x39, 0x43, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, + 0x37, 0x34, 0x34, 0x36, 0x38, 0x33, 0x33, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x30, 0x46, 0x33, 0x41, 0x39, 0x42, 0x33, 0x32, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x45, 0x42, 0x34, 0x38, + 0x39, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x34, + 0x37, 0x46, 0x44, 0x42, 0x35, 0x34, 0x34, 0x41, 0x34, 0x30, 0x0a, 0x38, + 0x36, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, + 0x33, 0x43, 0x31, 0x43, 0x44, 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x34, 0x31, 0x43, 0x37, 0x32, 0x37, 0x44, 0x34, 0x46, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x34, 0x43, 0x36, 0x46, 0x43, + 0x33, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x32, + 0x43, 0x45, 0x45, 0x31, 0x42, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x38, 0x31, 0x33, 0x44, 0x39, 0x46, 0x32, 0x33, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, 0x43, 0x32, 0x32, 0x36, 0x31, + 0x41, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x38, + 0x34, 0x43, 0x34, 0x33, 0x37, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x41, 0x37, 0x32, 0x39, 0x34, 0x45, 0x30, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x46, 0x37, 0x38, 0x31, 0x36, + 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, + 0x33, 0x41, 0x36, 0x37, 0x32, 0x31, 0x37, 0x34, 0x30, 0x0a, 0x38, 0x36, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x34, 0x39, + 0x36, 0x33, 0x41, 0x43, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x34, 0x44, 0x45, 0x43, 0x39, 0x33, 0x31, 0x34, 0x38, 0x34, 0x30, + 0x43, 0x38, 0x32, 0x32, 0x39, 0x39, 0x39, 0x37, 0x39, 0x43, 0x46, 0x37, + 0x34, 0x38, 0x34, 0x30, 0x42, 0x30, 0x46, 0x31, 0x42, 0x43, 0x44, 0x33, + 0x30, 0x39, 0x33, 0x38, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x38, 0x36, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x36, 0x43, 0x33, + 0x38, 0x38, 0x41, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x42, 0x34, 0x38, 0x32, 0x37, 0x31, 0x34, 0x39, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x36, 0x32, 0x37, 0x35, 0x46, 0x35, 0x39, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x33, 0x38, 0x38, + 0x34, 0x36, 0x46, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x34, 0x31, 0x44, 0x33, 0x42, 0x42, 0x32, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x36, 0x41, 0x42, 0x36, 0x44, 0x38, 0x32, + 0x31, 0x34, 0x30, 0x0a, 0x38, 0x36, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x35, 0x39, 0x36, 0x31, 0x36, 0x38, 0x34, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, 0x39, 0x30, 0x33, 0x44, + 0x35, 0x35, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, + 0x43, 0x44, 0x37, 0x34, 0x38, 0x42, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x37, 0x44, 0x31, 0x34, 0x35, 0x33, 0x33, 0x38, + 0x34, 0x30, 0x0a, 0x38, 0x36, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x36, 0x32, 0x44, 0x39, 0x46, 0x30, 0x32, 0x35, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x36, 0x37, 0x38, 0x30, 0x31, + 0x46, 0x32, 0x35, 0x34, 0x30, 0x45, 0x44, 0x37, 0x30, 0x36, 0x44, 0x37, + 0x44, 0x37, 0x34, 0x39, 0x42, 0x34, 0x30, 0x34, 0x30, 0x42, 0x32, 0x46, + 0x38, 0x31, 0x37, 0x34, 0x33, 0x35, 0x33, 0x36, 0x30, 0x33, 0x34, 0x34, + 0x30, 0x0a, 0x38, 0x36, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x43, 0x42, 0x30, 0x37, 0x37, 0x41, 0x32, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x30, 0x39, 0x39, 0x41, 0x42, 0x35, + 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x33, 0x46, + 0x42, 0x39, 0x38, 0x43, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x34, 0x34, 0x32, 0x37, 0x30, 0x35, 0x33, 0x46, 0x34, 0x30, + 0x36, 0x36, 0x31, 0x44, 0x33, 0x32, 0x35, 0x38, 0x32, 0x30, 0x36, 0x30, + 0x34, 0x44, 0x34, 0x30, 0x32, 0x46, 0x35, 0x32, 0x33, 0x39, 0x31, 0x33, + 0x45, 0x46, 0x39, 0x38, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x38, 0x36, 0x39, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x44, 0x30, + 0x35, 0x42, 0x39, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x43, 0x35, 0x42, 0x41, 0x34, 0x43, 0x34, 0x34, 0x46, 0x34, 0x30, 0x35, + 0x31, 0x35, 0x31, 0x44, 0x43, 0x45, 0x45, 0x41, 0x41, 0x44, 0x45, 0x34, + 0x31, 0x34, 0x30, 0x31, 0x46, 0x46, 0x45, 0x33, 0x37, 0x42, 0x37, 0x34, + 0x34, 0x31, 0x45, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x38, 0x37, 0x30, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x43, 0x37, 0x38, 0x43, + 0x46, 0x37, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, + 0x32, 0x43, 0x37, 0x33, 0x44, 0x31, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x34, 0x41, 0x36, 0x31, 0x37, 0x30, 0x46, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x32, 0x37, 0x31, 0x39, 0x43, + 0x30, 0x41, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x33, 0x38, 0x34, 0x44, 0x36, 0x42, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x37, 0x32, 0x41, 0x43, 0x46, 0x30, 0x35, 0x38, + 0x34, 0x30, 0x0a, 0x38, 0x37, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x45, 0x33, 0x30, 0x34, 0x32, 0x46, 0x42, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x36, 0x42, 0x38, 0x45, 0x31, + 0x32, 0x35, 0x37, 0x34, 0x30, 0x41, 0x34, 0x45, 0x31, 0x32, 0x45, 0x31, + 0x30, 0x35, 0x46, 0x44, 0x36, 0x35, 0x33, 0x34, 0x30, 0x45, 0x43, 0x33, + 0x36, 0x39, 0x37, 0x46, 0x41, 0x34, 0x41, 0x30, 0x33, 0x35, 0x34, 0x34, + 0x30, 0x0a, 0x38, 0x37, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x45, 0x34, 0x41, 0x46, 0x34, 0x42, 0x31, 0x35, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x41, 0x35, 0x35, 0x34, 0x34, 0x44, + 0x34, 0x36, 0x34, 0x30, 0x43, 0x43, 0x42, 0x39, 0x43, 0x44, 0x44, 0x44, + 0x33, 0x31, 0x44, 0x33, 0x34, 0x36, 0x34, 0x30, 0x42, 0x30, 0x38, 0x32, + 0x35, 0x38, 0x42, 0x38, 0x30, 0x39, 0x39, 0x46, 0x33, 0x34, 0x34, 0x30, + 0x0a, 0x38, 0x37, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x43, 0x32, 0x42, 0x45, 0x42, 0x45, 0x39, 0x34, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x30, 0x46, 0x42, 0x44, 0x34, 0x35, 0x30, 0x32, + 0x30, 0x34, 0x30, 0x34, 0x42, 0x43, 0x34, 0x30, 0x45, 0x34, 0x42, 0x42, + 0x31, 0x34, 0x31, 0x34, 0x31, 0x34, 0x30, 0x42, 0x36, 0x32, 0x45, 0x41, + 0x41, 0x36, 0x44, 0x43, 0x41, 0x44, 0x30, 0x33, 0x41, 0x34, 0x30, 0x0a, + 0x38, 0x37, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x32, 0x38, 0x45, 0x46, 0x44, 0x44, 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x38, 0x41, 0x30, 0x42, 0x44, 0x35, 0x33, 0x33, 0x30, + 0x34, 0x30, 0x32, 0x39, 0x35, 0x34, 0x41, 0x41, 0x37, 0x32, 0x43, 0x45, + 0x36, 0x44, 0x33, 0x39, 0x34, 0x30, 0x36, 0x38, 0x37, 0x41, 0x37, 0x37, + 0x37, 0x37, 0x44, 0x31, 0x33, 0x44, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x38, + 0x37, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x45, + 0x37, 0x30, 0x33, 0x44, 0x45, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x41, 0x30, 0x39, 0x43, 0x39, 0x37, 0x43, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x45, 0x32, 0x44, 0x32, 0x46, + 0x32, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, + 0x42, 0x37, 0x31, 0x45, 0x32, 0x34, 0x43, 0x34, 0x30, 0x31, 0x30, 0x44, + 0x32, 0x31, 0x46, 0x33, 0x39, 0x39, 0x32, 0x34, 0x35, 0x34, 0x42, 0x34, + 0x30, 0x33, 0x30, 0x42, 0x38, 0x38, 0x36, 0x43, 0x36, 0x32, 0x38, 0x32, + 0x30, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x38, 0x37, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x36, 0x34, 0x36, 0x39, 0x42, 0x43, + 0x32, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x30, 0x38, + 0x42, 0x46, 0x32, 0x37, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x38, 0x36, 0x35, 0x34, 0x41, 0x30, 0x34, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x44, 0x31, 0x32, 0x36, 0x46, 0x46, + 0x34, 0x36, 0x34, 0x30, 0x33, 0x37, 0x36, 0x36, 0x43, 0x35, 0x44, 0x33, + 0x38, 0x33, 0x35, 0x42, 0x34, 0x43, 0x34, 0x30, 0x37, 0x31, 0x31, 0x42, + 0x42, 0x32, 0x34, 0x42, 0x30, 0x32, 0x32, 0x38, 0x34, 0x43, 0x34, 0x30, + 0x0a, 0x38, 0x37, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x38, 0x33, 0x37, 0x38, 0x46, 0x33, 0x30, 0x33, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x38, 0x35, 0x32, 0x30, 0x37, 0x37, 0x35, 0x33, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x43, 0x32, 0x46, + 0x44, 0x41, 0x33, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x38, 0x30, 0x44, 0x42, 0x31, 0x31, 0x31, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x36, 0x36, 0x32, 0x37, 0x41, 0x30, 0x45, 0x35, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x32, 0x44, 0x45, + 0x39, 0x38, 0x45, 0x31, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x33, 0x35, 0x43, 0x31, 0x44, 0x45, 0x30, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x30, 0x36, 0x39, 0x33, 0x37, 0x41, 0x35, 0x33, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x31, 0x42, + 0x32, 0x33, 0x46, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x41, 0x46, 0x37, 0x39, 0x34, 0x39, 0x37, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x30, 0x39, 0x33, 0x45, 0x35, 0x41, 0x39, 0x34, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x42, 0x39, 0x37, + 0x32, 0x34, 0x33, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x36, 0x39, 0x41, 0x36, 0x42, 0x32, 0x33, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x43, 0x38, 0x33, 0x31, 0x33, 0x37, 0x38, 0x35, + 0x38, 0x34, 0x30, 0x0a, 0x38, 0x37, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x43, 0x30, 0x45, 0x34, 0x34, 0x35, 0x44, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x35, 0x31, 0x33, 0x32, + 0x34, 0x43, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x36, 0x33, 0x32, 0x46, 0x33, 0x46, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x42, 0x31, 0x31, 0x33, 0x34, 0x44, 0x31, 0x46, + 0x34, 0x30, 0x0a, 0x38, 0x37, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x33, 0x45, 0x37, 0x30, 0x44, 0x32, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x43, 0x39, 0x45, + 0x38, 0x34, 0x41, 0x34, 0x30, 0x39, 0x46, 0x43, 0x35, 0x39, 0x44, 0x30, + 0x41, 0x30, 0x37, 0x38, 0x32, 0x34, 0x30, 0x34, 0x30, 0x35, 0x42, 0x39, + 0x36, 0x43, 0x44, 0x33, 0x45, 0x41, 0x39, 0x41, 0x45, 0x35, 0x32, 0x34, + 0x30, 0x0a, 0x38, 0x38, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x34, 0x41, 0x37, 0x32, 0x45, 0x33, 0x45, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x46, 0x43, 0x37, 0x36, 0x43, 0x34, + 0x34, 0x46, 0x34, 0x30, 0x34, 0x39, 0x31, 0x44, 0x31, 0x42, 0x38, 0x35, + 0x46, 0x46, 0x36, 0x33, 0x34, 0x41, 0x34, 0x30, 0x41, 0x43, 0x41, 0x41, + 0x39, 0x41, 0x44, 0x43, 0x39, 0x30, 0x41, 0x43, 0x33, 0x38, 0x34, 0x30, + 0x0a, 0x38, 0x38, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x30, 0x38, 0x37, 0x34, 0x45, 0x33, 0x44, 0x33, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x34, 0x41, 0x37, 0x41, 0x38, 0x32, 0x43, 0x34, + 0x31, 0x34, 0x30, 0x33, 0x38, 0x33, 0x35, 0x38, 0x38, 0x42, 0x45, 0x45, + 0x30, 0x35, 0x43, 0x35, 0x33, 0x34, 0x30, 0x36, 0x33, 0x44, 0x36, 0x30, + 0x39, 0x42, 0x44, 0x33, 0x32, 0x39, 0x38, 0x34, 0x44, 0x34, 0x30, 0x0a, + 0x38, 0x38, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, + 0x36, 0x39, 0x32, 0x35, 0x41, 0x36, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x38, 0x32, 0x38, 0x41, 0x36, 0x30, 0x43, 0x33, 0x42, + 0x34, 0x30, 0x36, 0x30, 0x42, 0x41, 0x34, 0x31, 0x35, 0x41, 0x45, 0x44, + 0x42, 0x37, 0x35, 0x32, 0x34, 0x30, 0x34, 0x39, 0x31, 0x33, 0x36, 0x44, + 0x33, 0x38, 0x30, 0x35, 0x36, 0x30, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x38, + 0x38, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x46, + 0x35, 0x35, 0x31, 0x30, 0x44, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x30, 0x44, 0x44, 0x38, 0x42, 0x43, 0x33, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, 0x31, 0x42, 0x45, 0x33, 0x34, + 0x43, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x45, + 0x45, 0x34, 0x32, 0x34, 0x37, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x30, 0x32, 0x31, 0x38, 0x39, 0x34, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x35, 0x41, 0x32, 0x35, + 0x45, 0x46, 0x30, 0x33, 0x46, 0x0a, 0x38, 0x38, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x39, 0x39, 0x45, 0x34, 0x44, 0x33, + 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x42, 0x45, + 0x39, 0x44, 0x41, 0x46, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x41, 0x46, 0x31, 0x37, 0x44, 0x32, 0x36, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, 0x36, 0x37, 0x31, 0x37, 0x43, 0x35, + 0x34, 0x37, 0x34, 0x30, 0x0a, 0x38, 0x38, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x32, 0x33, 0x31, 0x43, 0x38, 0x41, 0x31, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x34, 0x46, 0x31, + 0x38, 0x38, 0x42, 0x34, 0x37, 0x34, 0x30, 0x35, 0x35, 0x35, 0x37, 0x46, + 0x41, 0x38, 0x39, 0x38, 0x43, 0x42, 0x39, 0x33, 0x34, 0x34, 0x30, 0x35, + 0x37, 0x44, 0x44, 0x31, 0x43, 0x31, 0x38, 0x41, 0x30, 0x31, 0x32, 0x34, + 0x45, 0x34, 0x30, 0x0a, 0x38, 0x38, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x34, 0x46, 0x46, 0x41, 0x42, 0x33, 0x36, 0x34, 0x45, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x45, 0x33, 0x42, 0x36, 0x35, + 0x42, 0x43, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x45, + 0x45, 0x34, 0x45, 0x41, 0x45, 0x42, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x41, 0x39, 0x33, 0x45, 0x35, 0x33, + 0x34, 0x30, 0x0a, 0x38, 0x38, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x45, 0x34, 0x32, 0x43, 0x45, 0x45, 0x33, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x34, 0x31, 0x34, 0x38, 0x31, + 0x35, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x44, + 0x38, 0x33, 0x44, 0x41, 0x45, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x34, 0x35, 0x45, 0x42, 0x31, 0x33, 0x30, 0x35, 0x32, 0x34, + 0x30, 0x0a, 0x38, 0x38, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x36, 0x45, 0x32, 0x30, 0x33, 0x30, 0x35, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x45, 0x39, 0x32, 0x42, 0x37, 0x32, + 0x35, 0x32, 0x34, 0x30, 0x44, 0x36, 0x30, 0x44, 0x42, 0x33, 0x36, 0x30, + 0x31, 0x31, 0x32, 0x45, 0x34, 0x45, 0x34, 0x30, 0x30, 0x46, 0x36, 0x42, + 0x32, 0x38, 0x35, 0x45, 0x35, 0x46, 0x30, 0x33, 0x35, 0x32, 0x34, 0x30, + 0x0a, 0x38, 0x38, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x32, 0x37, 0x45, 0x39, 0x39, 0x30, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x43, 0x44, 0x42, 0x45, 0x42, 0x32, 0x39, 0x34, + 0x31, 0x34, 0x30, 0x37, 0x38, 0x35, 0x35, 0x44, 0x46, 0x44, 0x33, 0x37, + 0x33, 0x35, 0x31, 0x33, 0x36, 0x34, 0x30, 0x35, 0x39, 0x45, 0x35, 0x38, + 0x37, 0x35, 0x36, 0x39, 0x33, 0x44, 0x34, 0x34, 0x46, 0x34, 0x30, 0x0a, + 0x38, 0x39, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x37, 0x31, 0x30, 0x46, 0x31, 0x39, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x34, 0x34, 0x37, 0x44, 0x30, 0x45, 0x42, 0x35, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x46, 0x43, 0x32, + 0x30, 0x45, 0x32, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, + 0x31, 0x33, 0x44, 0x35, 0x43, 0x39, 0x34, 0x41, 0x34, 0x30, 0x39, 0x42, + 0x37, 0x39, 0x34, 0x34, 0x30, 0x41, 0x39, 0x32, 0x30, 0x46, 0x34, 0x30, + 0x34, 0x30, 0x34, 0x38, 0x33, 0x32, 0x30, 0x35, 0x30, 0x39, 0x38, 0x41, + 0x37, 0x33, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x38, 0x39, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x37, 0x44, 0x42, 0x43, 0x42, + 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x37, 0x36, 0x42, 0x38, 0x34, 0x45, 0x42, 0x33, 0x46, 0x39, 0x44, 0x35, + 0x30, 0x35, 0x38, 0x33, 0x31, 0x37, 0x38, 0x32, 0x32, 0x35, 0x31, 0x34, + 0x30, 0x38, 0x30, 0x33, 0x37, 0x39, 0x33, 0x42, 0x35, 0x42, 0x37, 0x43, + 0x31, 0x33, 0x46, 0x34, 0x30, 0x0a, 0x38, 0x39, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x35, 0x37, 0x36, 0x33, 0x30, 0x36, + 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x46, 0x38, + 0x46, 0x36, 0x39, 0x43, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x43, 0x43, 0x46, 0x31, 0x46, 0x31, 0x38, 0x34, 0x44, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x32, 0x36, 0x31, 0x44, 0x38, 0x38, 0x36, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x41, 0x31, + 0x30, 0x32, 0x41, 0x30, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x30, 0x30, 0x41, 0x37, 0x41, 0x38, 0x39, 0x31, 0x31, 0x34, 0x30, + 0x0a, 0x38, 0x39, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x41, 0x46, 0x39, 0x44, 0x41, 0x45, 0x31, 0x35, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x38, 0x35, 0x34, 0x30, 0x34, 0x46, 0x42, 0x34, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x41, 0x37, 0x32, + 0x42, 0x31, 0x35, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x34, 0x45, 0x39, 0x38, 0x38, 0x32, 0x32, 0x31, 0x34, 0x30, 0x33, + 0x43, 0x33, 0x35, 0x39, 0x36, 0x45, 0x43, 0x30, 0x37, 0x30, 0x42, 0x34, + 0x44, 0x34, 0x30, 0x46, 0x43, 0x42, 0x41, 0x37, 0x41, 0x45, 0x42, 0x41, + 0x32, 0x30, 0x32, 0x33, 0x35, 0x34, 0x30, 0x0a, 0x38, 0x39, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x37, 0x45, 0x43, 0x35, + 0x41, 0x42, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x45, 0x37, 0x36, 0x37, 0x44, 0x43, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x36, 0x46, 0x41, 0x38, 0x33, 0x37, 0x38, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x42, 0x44, 0x41, 0x33, + 0x33, 0x39, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, + 0x36, 0x45, 0x43, 0x36, 0x43, 0x43, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x30, 0x31, 0x45, 0x39, 0x41, 0x34, 0x33, 0x30, 0x46, + 0x34, 0x30, 0x43, 0x45, 0x36, 0x36, 0x33, 0x32, 0x43, 0x39, 0x39, 0x46, + 0x43, 0x32, 0x35, 0x32, 0x34, 0x30, 0x33, 0x36, 0x30, 0x46, 0x42, 0x46, + 0x41, 0x31, 0x33, 0x31, 0x37, 0x35, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x38, + 0x39, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x34, + 0x36, 0x30, 0x41, 0x37, 0x31, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x45, 0x32, 0x36, 0x30, 0x30, 0x38, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x46, 0x31, 0x37, 0x37, 0x30, + 0x34, 0x30, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x36, + 0x41, 0x38, 0x30, 0x31, 0x42, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x30, 0x31, 0x41, 0x30, 0x32, 0x33, 0x38, 0x32, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x45, 0x41, 0x33, 0x32, 0x43, + 0x37, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x42, + 0x34, 0x30, 0x42, 0x33, 0x42, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x34, 0x32, 0x36, 0x35, 0x30, 0x34, 0x43, 0x34, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x45, 0x31, 0x31, 0x42, 0x37, + 0x36, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x32, + 0x39, 0x38, 0x30, 0x32, 0x41, 0x34, 0x35, 0x34, 0x30, 0x0a, 0x38, 0x39, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x33, + 0x36, 0x32, 0x35, 0x46, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x44, 0x30, 0x35, 0x45, 0x39, 0x34, 0x37, 0x30, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x39, 0x46, 0x42, 0x43, 0x39, 0x43, + 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x38, 0x35, + 0x38, 0x39, 0x36, 0x41, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x38, 0x36, 0x33, 0x42, 0x39, 0x39, 0x45, 0x33, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x32, 0x45, 0x33, 0x32, 0x46, 0x42, + 0x31, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x42, + 0x36, 0x41, 0x32, 0x31, 0x31, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x43, 0x43, 0x32, 0x30, 0x32, 0x33, 0x31, 0x43, 0x34, 0x41, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x46, 0x37, 0x46, 0x43, 0x45, + 0x32, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, + 0x46, 0x45, 0x42, 0x31, 0x45, 0x45, 0x33, 0x46, 0x0a, 0x38, 0x39, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x33, 0x34, 0x32, + 0x39, 0x44, 0x36, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x43, 0x46, 0x39, 0x42, 0x33, 0x43, 0x38, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x34, 0x44, 0x46, 0x31, 0x45, 0x31, 0x37, 0x34, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x38, 0x33, + 0x30, 0x45, 0x36, 0x31, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x30, 0x45, 0x46, 0x44, 0x45, 0x33, 0x35, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x35, 0x41, 0x31, 0x43, 0x44, + 0x34, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, 0x36, 0x34, 0x32, + 0x44, 0x39, 0x39, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x34, 0x45, 0x30, 0x42, 0x39, 0x41, 0x36, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x37, 0x37, 0x41, 0x36, 0x32, 0x46, 0x34, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x44, 0x35, 0x31, + 0x42, 0x38, 0x35, 0x35, 0x36, 0x34, 0x30, 0x0a, 0x38, 0x39, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x46, 0x36, 0x45, 0x44, + 0x44, 0x46, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, + 0x33, 0x46, 0x39, 0x43, 0x41, 0x30, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x44, 0x37, 0x43, 0x30, 0x35, 0x34, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x38, 0x33, + 0x39, 0x43, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x41, 0x41, 0x45, 0x35, 0x45, 0x42, 0x30, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x41, 0x32, 0x39, 0x45, 0x36, 0x41, 0x38, 0x35, 0x31, + 0x34, 0x30, 0x0a, 0x38, 0x39, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x43, 0x38, 0x34, 0x33, 0x45, 0x30, 0x39, 0x34, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x34, 0x38, 0x37, 0x44, 0x42, + 0x46, 0x32, 0x34, 0x34, 0x30, 0x35, 0x30, 0x33, 0x44, 0x38, 0x44, 0x36, + 0x30, 0x32, 0x38, 0x32, 0x34, 0x34, 0x39, 0x34, 0x30, 0x35, 0x36, 0x41, + 0x42, 0x45, 0x43, 0x44, 0x46, 0x34, 0x45, 0x32, 0x42, 0x34, 0x30, 0x34, + 0x30, 0x0a, 0x39, 0x30, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x43, 0x41, 0x39, 0x30, 0x37, 0x42, 0x37, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x32, 0x32, 0x39, 0x34, 0x43, 0x33, + 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x35, 0x45, + 0x41, 0x35, 0x36, 0x32, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x43, 0x30, 0x34, 0x32, 0x34, 0x43, 0x42, 0x35, 0x38, 0x34, 0x30, + 0x42, 0x38, 0x34, 0x41, 0x37, 0x33, 0x37, 0x44, 0x36, 0x41, 0x42, 0x33, + 0x34, 0x37, 0x34, 0x30, 0x45, 0x37, 0x36, 0x37, 0x44, 0x43, 0x42, 0x42, + 0x42, 0x30, 0x33, 0x33, 0x35, 0x35, 0x34, 0x30, 0x0a, 0x39, 0x30, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x32, 0x46, 0x36, 0x31, + 0x46, 0x44, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x45, 0x30, 0x30, 0x43, 0x38, 0x38, 0x35, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x41, 0x37, 0x31, 0x32, 0x41, 0x34, 0x35, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x35, 0x35, 0x35, + 0x32, 0x34, 0x44, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x30, 0x31, 0x45, 0x46, 0x34, 0x31, 0x38, 0x32, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x32, 0x43, 0x43, 0x32, 0x45, 0x46, 0x34, 0x35, + 0x31, 0x34, 0x30, 0x0a, 0x39, 0x30, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x41, 0x31, 0x35, 0x42, 0x34, 0x30, 0x32, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x45, 0x38, 0x33, 0x36, + 0x36, 0x32, 0x35, 0x38, 0x34, 0x30, 0x45, 0x38, 0x36, 0x37, 0x42, 0x36, + 0x42, 0x30, 0x33, 0x41, 0x32, 0x42, 0x34, 0x32, 0x34, 0x30, 0x35, 0x31, + 0x42, 0x44, 0x46, 0x41, 0x39, 0x46, 0x45, 0x36, 0x31, 0x39, 0x35, 0x30, + 0x34, 0x30, 0x0a, 0x39, 0x30, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x30, 0x37, 0x30, 0x35, 0x44, 0x35, 0x41, 0x33, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, 0x32, 0x43, 0x46, 0x32, 0x33, + 0x37, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, + 0x41, 0x30, 0x36, 0x36, 0x41, 0x33, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x38, 0x36, 0x42, 0x41, 0x30, 0x46, 0x35, 0x35, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x38, 0x35, 0x35, 0x30, 0x41, + 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x41, 0x33, 0x30, 0x39, 0x34, 0x30, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x36, 0x36, 0x43, 0x36, 0x38, 0x37, 0x42, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x45, 0x43, 0x46, 0x35, 0x44, + 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x44, + 0x42, 0x46, 0x33, 0x33, 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x41, 0x46, 0x30, 0x38, 0x36, 0x44, 0x45, 0x35, 0x37, 0x34, + 0x30, 0x0a, 0x39, 0x30, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x36, 0x39, 0x34, 0x33, 0x30, 0x46, 0x35, 0x34, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x34, 0x39, 0x33, 0x33, 0x34, + 0x32, 0x32, 0x34, 0x30, 0x38, 0x32, 0x42, 0x44, 0x38, 0x36, 0x37, 0x34, + 0x35, 0x37, 0x39, 0x44, 0x34, 0x44, 0x34, 0x30, 0x36, 0x41, 0x44, 0x32, + 0x46, 0x34, 0x34, 0x35, 0x39, 0x37, 0x38, 0x37, 0x32, 0x46, 0x34, 0x30, + 0x0a, 0x39, 0x30, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x42, 0x36, 0x33, 0x36, 0x35, 0x31, 0x30, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x38, 0x43, 0x42, 0x46, 0x36, 0x42, 0x39, 0x35, + 0x35, 0x34, 0x30, 0x37, 0x34, 0x39, 0x41, 0x41, 0x44, 0x42, 0x45, 0x31, + 0x35, 0x39, 0x41, 0x32, 0x46, 0x34, 0x30, 0x38, 0x33, 0x39, 0x44, 0x37, + 0x46, 0x41, 0x36, 0x43, 0x31, 0x32, 0x46, 0x33, 0x43, 0x34, 0x30, 0x0a, + 0x39, 0x30, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x42, 0x46, 0x34, 0x38, 0x44, 0x37, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x30, 0x36, 0x30, 0x35, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x41, 0x38, 0x42, 0x33, 0x38, + 0x42, 0x42, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, + 0x38, 0x31, 0x32, 0x43, 0x45, 0x41, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x34, 0x35, 0x38, 0x36, 0x33, 0x41, 0x37, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x44, 0x45, 0x36, 0x34, + 0x30, 0x30, 0x33, 0x34, 0x34, 0x30, 0x44, 0x38, 0x33, 0x33, 0x35, 0x34, + 0x32, 0x45, 0x30, 0x46, 0x43, 0x30, 0x35, 0x37, 0x34, 0x30, 0x44, 0x31, + 0x42, 0x44, 0x39, 0x44, 0x34, 0x39, 0x45, 0x33, 0x43, 0x36, 0x33, 0x35, + 0x34, 0x30, 0x0a, 0x39, 0x30, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x45, 0x39, 0x34, 0x31, 0x31, 0x39, 0x44, 0x35, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x34, 0x42, 0x35, 0x32, 0x33, + 0x46, 0x31, 0x45, 0x34, 0x30, 0x39, 0x45, 0x30, 0x30, 0x42, 0x33, 0x42, + 0x30, 0x46, 0x41, 0x36, 0x39, 0x34, 0x43, 0x34, 0x30, 0x36, 0x34, 0x44, + 0x44, 0x31, 0x38, 0x38, 0x41, 0x42, 0x31, 0x35, 0x36, 0x34, 0x43, 0x34, + 0x30, 0x0a, 0x39, 0x30, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x41, 0x39, 0x30, 0x46, 0x42, 0x45, 0x41, 0x35, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x30, 0x35, 0x30, 0x30, 0x46, 0x45, + 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x33, 0x46, + 0x42, 0x45, 0x35, 0x42, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x39, 0x34, 0x34, 0x35, 0x36, 0x44, 0x35, 0x30, 0x34, 0x30, + 0x0a, 0x39, 0x30, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x43, 0x36, 0x46, 0x39, 0x30, 0x31, 0x31, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x30, 0x32, 0x44, 0x39, 0x43, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x35, 0x46, 0x31, + 0x44, 0x34, 0x42, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x30, 0x37, 0x32, 0x45, 0x39, 0x45, 0x35, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x38, 0x43, 0x31, 0x46, 0x33, 0x45, 0x41, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x46, 0x43, + 0x31, 0x32, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x36, 0x36, 0x32, 0x33, 0x34, 0x30, 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x38, 0x33, 0x37, 0x42, 0x30, 0x32, + 0x36, 0x34, 0x30, 0x0a, 0x39, 0x31, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x46, 0x34, 0x41, 0x44, 0x31, 0x32, 0x36, 0x43, 0x34, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x34, 0x34, 0x33, 0x31, + 0x41, 0x39, 0x31, 0x41, 0x34, 0x30, 0x39, 0x44, 0x45, 0x31, 0x45, 0x37, + 0x31, 0x33, 0x32, 0x45, 0x39, 0x37, 0x35, 0x35, 0x34, 0x30, 0x31, 0x45, + 0x33, 0x32, 0x42, 0x37, 0x46, 0x30, 0x41, 0x41, 0x42, 0x41, 0x34, 0x31, + 0x34, 0x30, 0x0a, 0x39, 0x31, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x38, 0x36, 0x39, 0x45, 0x36, 0x37, 0x43, 0x35, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x35, 0x39, 0x45, 0x38, + 0x32, 0x34, 0x45, 0x34, 0x30, 0x45, 0x33, 0x41, 0x32, 0x39, 0x41, 0x41, + 0x35, 0x33, 0x39, 0x43, 0x31, 0x34, 0x46, 0x34, 0x30, 0x34, 0x43, 0x39, + 0x43, 0x38, 0x34, 0x32, 0x35, 0x37, 0x39, 0x43, 0x42, 0x34, 0x37, 0x34, + 0x30, 0x0a, 0x39, 0x31, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x45, 0x31, 0x36, 0x39, 0x31, 0x43, 0x46, 0x35, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x42, 0x39, 0x35, 0x33, 0x39, 0x45, + 0x34, 0x34, 0x34, 0x30, 0x34, 0x31, 0x45, 0x31, 0x41, 0x45, 0x35, 0x39, + 0x45, 0x38, 0x35, 0x35, 0x34, 0x30, 0x34, 0x30, 0x39, 0x43, 0x34, 0x35, + 0x33, 0x42, 0x39, 0x33, 0x35, 0x37, 0x32, 0x31, 0x32, 0x44, 0x34, 0x30, + 0x0a, 0x39, 0x31, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x36, 0x37, 0x42, 0x34, 0x43, 0x45, 0x46, 0x32, 0x33, 0x46, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x43, 0x39, 0x37, 0x33, 0x30, 0x43, 0x30, 0x34, + 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x41, 0x30, 0x46, 0x44, + 0x45, 0x32, 0x34, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x43, 0x35, 0x33, 0x41, 0x36, 0x42, 0x35, 0x34, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x38, 0x42, 0x38, 0x41, 0x39, 0x38, 0x43, 0x34, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x34, 0x36, 0x42, 0x43, + 0x39, 0x30, 0x46, 0x35, 0x34, 0x34, 0x30, 0x0a, 0x39, 0x31, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x46, 0x38, 0x45, 0x33, + 0x37, 0x45, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, + 0x35, 0x35, 0x44, 0x32, 0x46, 0x42, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x43, 0x39, 0x44, 0x36, 0x41, 0x44, 0x38, 0x34, 0x45, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x46, 0x39, 0x45, + 0x41, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x32, + 0x34, 0x30, 0x31, 0x32, 0x41, 0x32, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x30, 0x43, 0x33, 0x34, 0x38, 0x31, 0x32, 0x32, 0x43, + 0x34, 0x30, 0x0a, 0x39, 0x31, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x41, 0x46, 0x34, 0x36, 0x45, 0x33, 0x34, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x45, 0x42, 0x45, 0x35, 0x41, + 0x32, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x32, + 0x42, 0x39, 0x37, 0x35, 0x42, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x35, 0x43, 0x31, 0x33, 0x34, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x30, 0x41, 0x41, 0x38, 0x33, + 0x44, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x32, + 0x30, 0x38, 0x35, 0x36, 0x36, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x34, 0x31, 0x30, 0x31, 0x34, 0x36, 0x42, 0x34, 0x43, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x41, 0x38, 0x42, 0x42, + 0x35, 0x30, 0x30, 0x34, 0x30, 0x0a, 0x39, 0x31, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x34, 0x35, 0x36, 0x30, 0x43, 0x39, + 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x31, 0x33, + 0x31, 0x36, 0x30, 0x32, 0x35, 0x30, 0x34, 0x30, 0x45, 0x41, 0x30, 0x35, + 0x45, 0x34, 0x38, 0x31, 0x37, 0x30, 0x41, 0x44, 0x35, 0x34, 0x34, 0x30, + 0x42, 0x30, 0x42, 0x37, 0x37, 0x37, 0x39, 0x43, 0x38, 0x32, 0x46, 0x32, + 0x34, 0x41, 0x34, 0x30, 0x0a, 0x39, 0x31, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x36, 0x46, 0x32, 0x43, 0x39, 0x31, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x41, 0x36, 0x31, + 0x43, 0x37, 0x44, 0x33, 0x36, 0x34, 0x30, 0x33, 0x35, 0x31, 0x39, 0x36, + 0x42, 0x41, 0x45, 0x35, 0x32, 0x31, 0x42, 0x33, 0x30, 0x34, 0x30, 0x42, + 0x35, 0x37, 0x39, 0x45, 0x33, 0x34, 0x36, 0x33, 0x39, 0x42, 0x30, 0x34, + 0x33, 0x34, 0x30, 0x0a, 0x39, 0x31, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x43, 0x43, 0x46, 0x33, 0x34, 0x46, 0x32, 0x35, 0x34, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x45, 0x43, 0x31, 0x42, 0x36, + 0x39, 0x36, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, + 0x39, 0x41, 0x33, 0x39, 0x45, 0x37, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x32, 0x39, 0x32, 0x41, 0x37, 0x37, 0x34, 0x42, + 0x34, 0x30, 0x34, 0x45, 0x31, 0x31, 0x36, 0x44, 0x36, 0x42, 0x38, 0x36, + 0x39, 0x30, 0x33, 0x44, 0x34, 0x30, 0x44, 0x43, 0x44, 0x42, 0x42, 0x46, + 0x46, 0x46, 0x42, 0x44, 0x36, 0x35, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x39, + 0x31, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x30, + 0x31, 0x43, 0x45, 0x41, 0x44, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x41, 0x41, 0x31, 0x34, 0x38, 0x42, 0x33, 0x35, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x33, 0x45, 0x45, 0x41, + 0x30, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x46, + 0x46, 0x34, 0x34, 0x46, 0x38, 0x35, 0x38, 0x34, 0x30, 0x43, 0x35, 0x43, + 0x37, 0x35, 0x45, 0x30, 0x45, 0x46, 0x45, 0x43, 0x45, 0x34, 0x32, 0x34, + 0x30, 0x43, 0x33, 0x43, 0x44, 0x30, 0x34, 0x44, 0x31, 0x42, 0x41, 0x30, + 0x41, 0x34, 0x42, 0x34, 0x30, 0x0a, 0x39, 0x32, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x34, 0x46, 0x31, 0x46, 0x41, 0x42, + 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x36, 0x33, + 0x30, 0x46, 0x44, 0x36, 0x32, 0x31, 0x34, 0x30, 0x33, 0x43, 0x33, 0x35, + 0x45, 0x45, 0x37, 0x34, 0x32, 0x32, 0x44, 0x38, 0x34, 0x42, 0x34, 0x30, + 0x37, 0x30, 0x38, 0x38, 0x44, 0x31, 0x43, 0x43, 0x39, 0x39, 0x35, 0x42, + 0x34, 0x39, 0x34, 0x30, 0x0a, 0x39, 0x32, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x37, 0x37, 0x33, 0x31, 0x43, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x37, 0x45, 0x37, + 0x39, 0x33, 0x38, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x38, 0x31, 0x37, 0x36, 0x38, 0x32, 0x35, 0x33, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x32, 0x32, 0x34, 0x46, 0x33, 0x44, 0x34, 0x35, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x34, 0x35, + 0x33, 0x42, 0x39, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x35, 0x45, 0x43, 0x43, 0x43, 0x31, 0x34, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x34, 0x41, 0x36, 0x33, 0x36, 0x34, + 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x35, 0x44, + 0x38, 0x37, 0x35, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x39, 0x32, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x43, 0x43, 0x34, 0x34, + 0x43, 0x37, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x34, + 0x46, 0x41, 0x41, 0x41, 0x37, 0x39, 0x34, 0x31, 0x34, 0x30, 0x46, 0x33, + 0x37, 0x41, 0x43, 0x31, 0x41, 0x42, 0x34, 0x37, 0x35, 0x43, 0x34, 0x42, + 0x34, 0x30, 0x31, 0x33, 0x30, 0x46, 0x46, 0x46, 0x36, 0x33, 0x42, 0x30, + 0x42, 0x44, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x39, 0x32, 0x33, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x32, 0x38, 0x44, 0x38, 0x35, + 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x33, + 0x33, 0x33, 0x31, 0x45, 0x42, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x34, 0x36, 0x33, 0x32, 0x34, 0x41, 0x32, 0x35, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x34, 0x37, 0x35, 0x39, 0x44, 0x31, + 0x46, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x39, 0x32, 0x34, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x41, 0x30, 0x37, 0x37, 0x43, 0x31, + 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x36, 0x39, + 0x42, 0x34, 0x37, 0x37, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x45, 0x35, 0x39, 0x33, 0x42, 0x39, 0x35, 0x35, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x33, 0x31, 0x34, 0x34, 0x31, 0x35, + 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x32, 0x36, + 0x42, 0x36, 0x44, 0x34, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x32, 0x31, 0x38, 0x36, 0x44, 0x38, 0x33, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x45, 0x41, 0x34, 0x41, 0x30, + 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x45, 0x41, + 0x35, 0x42, 0x42, 0x30, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x42, 0x37, 0x44, 0x34, 0x46, 0x45, 0x31, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x33, 0x31, 0x41, 0x31, 0x31, + 0x33, 0x38, 0x34, 0x30, 0x0a, 0x39, 0x32, 0x35, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x45, 0x36, 0x36, 0x34, 0x39, 0x42, 0x46, 0x35, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x33, 0x35, 0x33, + 0x35, 0x30, 0x37, 0x34, 0x46, 0x34, 0x30, 0x31, 0x33, 0x31, 0x34, 0x43, + 0x44, 0x35, 0x43, 0x44, 0x37, 0x35, 0x39, 0x35, 0x32, 0x34, 0x30, 0x44, + 0x41, 0x45, 0x37, 0x44, 0x44, 0x42, 0x33, 0x39, 0x39, 0x39, 0x44, 0x35, + 0x31, 0x34, 0x30, 0x0a, 0x39, 0x32, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x38, 0x41, 0x32, 0x38, 0x43, 0x36, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x32, 0x37, 0x31, 0x34, + 0x35, 0x45, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x38, 0x32, 0x31, 0x44, 0x44, 0x37, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x36, 0x43, 0x36, 0x34, 0x37, 0x32, 0x41, 0x35, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x32, 0x41, 0x44, 0x33, + 0x42, 0x35, 0x31, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x41, + 0x30, 0x45, 0x35, 0x42, 0x45, 0x36, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x39, + 0x32, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x34, 0x35, 0x35, 0x35, 0x46, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x30, 0x30, 0x42, 0x45, 0x33, 0x39, 0x31, 0x32, 0x44, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x31, 0x32, 0x43, 0x41, 0x37, + 0x43, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x42, + 0x42, 0x41, 0x39, 0x30, 0x44, 0x34, 0x38, 0x34, 0x30, 0x35, 0x42, 0x41, + 0x41, 0x33, 0x36, 0x36, 0x42, 0x35, 0x39, 0x42, 0x45, 0x35, 0x32, 0x34, + 0x30, 0x42, 0x39, 0x31, 0x37, 0x34, 0x41, 0x31, 0x35, 0x46, 0x45, 0x41, + 0x42, 0x34, 0x39, 0x34, 0x30, 0x0a, 0x39, 0x32, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x43, 0x32, 0x30, 0x35, 0x41, 0x37, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x38, 0x38, + 0x38, 0x44, 0x33, 0x42, 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x45, 0x37, 0x43, 0x43, 0x38, 0x46, 0x38, 0x33, 0x46, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x42, 0x41, 0x34, 0x30, 0x35, 0x35, + 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x41, 0x36, 0x31, + 0x44, 0x35, 0x37, 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x36, 0x38, 0x46, 0x46, 0x38, 0x36, 0x36, 0x35, 0x36, 0x34, 0x30, + 0x0a, 0x39, 0x32, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x32, 0x46, 0x38, 0x41, 0x35, 0x46, 0x44, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x45, 0x34, 0x45, 0x43, 0x43, 0x42, 0x33, 0x35, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, 0x45, 0x44, 0x37, + 0x38, 0x46, 0x39, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x41, 0x36, 0x32, 0x45, 0x42, 0x35, 0x33, 0x35, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x36, 0x33, 0x31, 0x46, 0x34, 0x33, 0x46, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, 0x36, 0x37, 0x36, + 0x39, 0x36, 0x34, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x38, 0x39, 0x45, 0x46, 0x45, 0x44, 0x42, 0x33, 0x38, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x36, 0x33, 0x42, 0x37, 0x39, 0x39, 0x37, 0x35, + 0x37, 0x34, 0x30, 0x0a, 0x39, 0x33, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x38, 0x36, 0x45, 0x34, 0x37, 0x36, 0x31, 0x35, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x41, 0x30, 0x39, 0x42, + 0x42, 0x35, 0x46, 0x30, 0x33, 0x46, 0x35, 0x46, 0x43, 0x41, 0x32, 0x43, + 0x44, 0x41, 0x46, 0x36, 0x32, 0x38, 0x32, 0x32, 0x34, 0x30, 0x37, 0x34, + 0x38, 0x31, 0x43, 0x31, 0x34, 0x44, 0x43, 0x39, 0x34, 0x46, 0x34, 0x30, + 0x34, 0x30, 0x0a, 0x39, 0x33, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x35, 0x37, 0x38, 0x32, 0x42, 0x36, 0x33, 0x39, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x30, 0x39, 0x35, 0x38, 0x34, + 0x46, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x30, + 0x38, 0x43, 0x32, 0x44, 0x45, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x38, 0x34, 0x38, 0x34, 0x45, 0x42, 0x36, 0x34, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x43, 0x43, 0x35, 0x44, 0x46, + 0x36, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x43, + 0x38, 0x32, 0x37, 0x30, 0x44, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x38, 0x32, 0x46, 0x39, 0x32, 0x37, 0x43, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x41, 0x35, 0x46, 0x38, 0x38, + 0x33, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x39, 0x33, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x34, 0x45, 0x38, 0x33, 0x34, 0x41, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x39, 0x39, + 0x39, 0x32, 0x46, 0x36, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x36, 0x33, 0x46, 0x30, 0x46, 0x37, 0x37, 0x35, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x44, 0x35, 0x33, 0x37, 0x36, 0x34, + 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x45, 0x39, + 0x30, 0x38, 0x44, 0x33, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x41, 0x30, 0x34, 0x33, 0x46, 0x35, 0x39, 0x35, 0x34, 0x44, 0x34, 0x30, + 0x0a, 0x39, 0x33, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x38, 0x36, 0x41, 0x45, 0x36, 0x34, 0x33, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x32, 0x34, 0x39, 0x46, 0x41, 0x30, 0x31, 0x35, + 0x35, 0x34, 0x30, 0x33, 0x32, 0x32, 0x33, 0x33, 0x39, 0x30, 0x38, 0x41, + 0x30, 0x34, 0x35, 0x34, 0x43, 0x34, 0x30, 0x31, 0x37, 0x46, 0x42, 0x45, + 0x42, 0x30, 0x41, 0x34, 0x41, 0x45, 0x30, 0x35, 0x31, 0x34, 0x30, 0x0a, + 0x39, 0x33, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, + 0x33, 0x44, 0x38, 0x33, 0x35, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x43, 0x34, 0x30, 0x36, 0x42, 0x34, 0x39, 0x34, 0x34, + 0x34, 0x30, 0x39, 0x45, 0x42, 0x35, 0x31, 0x44, 0x37, 0x36, 0x37, 0x38, + 0x37, 0x37, 0x34, 0x35, 0x34, 0x30, 0x38, 0x41, 0x46, 0x36, 0x32, 0x42, + 0x41, 0x35, 0x32, 0x30, 0x45, 0x41, 0x34, 0x42, 0x34, 0x30, 0x0a, 0x39, + 0x33, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x38, 0x36, + 0x44, 0x37, 0x42, 0x37, 0x34, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x44, 0x43, 0x38, 0x44, 0x30, 0x34, 0x32, 0x35, 0x34, + 0x30, 0x46, 0x45, 0x42, 0x31, 0x44, 0x46, 0x41, 0x36, 0x44, 0x42, 0x32, + 0x45, 0x35, 0x30, 0x34, 0x30, 0x35, 0x43, 0x39, 0x43, 0x39, 0x36, 0x35, + 0x45, 0x31, 0x41, 0x43, 0x42, 0x33, 0x41, 0x34, 0x30, 0x0a, 0x39, 0x33, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x32, + 0x39, 0x30, 0x44, 0x33, 0x32, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x43, 0x34, 0x45, 0x39, 0x32, 0x30, 0x43, 0x34, 0x32, 0x34, 0x30, + 0x32, 0x35, 0x36, 0x38, 0x39, 0x31, 0x35, 0x46, 0x36, 0x30, 0x39, 0x36, + 0x33, 0x43, 0x34, 0x30, 0x33, 0x34, 0x46, 0x34, 0x34, 0x34, 0x33, 0x41, + 0x38, 0x42, 0x38, 0x30, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x39, 0x33, 0x37, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x38, 0x30, 0x41, + 0x32, 0x32, 0x42, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x38, 0x35, 0x35, 0x34, 0x38, 0x31, 0x46, 0x34, 0x41, 0x34, 0x30, 0x37, + 0x38, 0x35, 0x45, 0x38, 0x35, 0x33, 0x42, 0x36, 0x30, 0x38, 0x43, 0x32, + 0x45, 0x34, 0x30, 0x42, 0x45, 0x43, 0x39, 0x43, 0x33, 0x44, 0x33, 0x35, + 0x36, 0x32, 0x45, 0x34, 0x45, 0x34, 0x30, 0x0a, 0x39, 0x33, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x44, 0x35, 0x36, 0x46, + 0x44, 0x37, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, + 0x44, 0x39, 0x44, 0x36, 0x34, 0x33, 0x35, 0x32, 0x34, 0x30, 0x45, 0x42, + 0x41, 0x37, 0x33, 0x31, 0x37, 0x39, 0x46, 0x31, 0x32, 0x36, 0x35, 0x31, + 0x34, 0x30, 0x33, 0x42, 0x31, 0x34, 0x45, 0x33, 0x33, 0x39, 0x41, 0x42, + 0x45, 0x34, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x39, 0x33, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x45, 0x41, 0x46, 0x38, 0x36, 0x44, + 0x45, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x45, 0x31, + 0x35, 0x34, 0x43, 0x31, 0x32, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x41, 0x38, 0x39, 0x30, 0x42, 0x30, 0x34, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x46, 0x46, 0x46, 0x41, 0x45, + 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x38, + 0x30, 0x45, 0x30, 0x34, 0x33, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x32, 0x42, 0x37, 0x30, 0x39, 0x42, 0x34, 0x39, 0x34, + 0x30, 0x42, 0x45, 0x33, 0x42, 0x31, 0x32, 0x41, 0x32, 0x41, 0x45, 0x34, + 0x34, 0x34, 0x36, 0x34, 0x30, 0x43, 0x35, 0x46, 0x39, 0x46, 0x46, 0x33, + 0x31, 0x36, 0x41, 0x38, 0x34, 0x34, 0x34, 0x34, 0x30, 0x0a, 0x39, 0x34, + 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x32, 0x43, 0x34, + 0x32, 0x35, 0x45, 0x42, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x41, 0x32, 0x32, 0x45, 0x30, 0x42, 0x45, 0x35, 0x30, 0x34, 0x30, + 0x36, 0x35, 0x37, 0x31, 0x44, 0x38, 0x42, 0x46, 0x41, 0x42, 0x36, 0x43, + 0x35, 0x35, 0x34, 0x30, 0x46, 0x30, 0x38, 0x30, 0x43, 0x32, 0x33, 0x35, + 0x43, 0x38, 0x44, 0x33, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x39, 0x34, 0x31, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x38, 0x43, 0x32, + 0x33, 0x34, 0x42, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x45, 0x31, 0x43, 0x31, 0x43, 0x42, 0x32, 0x45, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x45, 0x45, 0x39, 0x39, 0x34, 0x33, 0x31, 0x35, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x44, 0x32, 0x45, + 0x42, 0x36, 0x43, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x38, 0x43, 0x37, 0x39, 0x41, 0x45, 0x33, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x30, 0x44, 0x39, 0x42, 0x36, 0x35, 0x38, 0x32, + 0x45, 0x34, 0x30, 0x0a, 0x39, 0x34, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x43, 0x35, 0x39, 0x32, 0x31, 0x36, 0x35, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x38, 0x38, 0x32, 0x35, 0x46, + 0x38, 0x34, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, + 0x36, 0x36, 0x33, 0x31, 0x34, 0x30, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x38, 0x34, 0x36, 0x46, 0x37, 0x46, 0x35, 0x34, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x37, 0x44, 0x42, 0x38, + 0x39, 0x30, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, + 0x31, 0x31, 0x30, 0x34, 0x45, 0x46, 0x35, 0x37, 0x34, 0x30, 0x0a, 0x39, + 0x34, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x43, + 0x33, 0x45, 0x44, 0x45, 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x30, 0x30, 0x46, 0x44, 0x34, 0x45, 0x45, 0x34, 0x46, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x35, 0x39, 0x43, 0x35, + 0x32, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x45, + 0x35, 0x43, 0x44, 0x41, 0x36, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x39, 0x34, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x38, + 0x42, 0x36, 0x34, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x46, 0x41, 0x42, 0x37, 0x44, 0x38, 0x32, 0x42, 0x34, 0x30, + 0x31, 0x33, 0x43, 0x36, 0x31, 0x42, 0x34, 0x45, 0x38, 0x32, 0x33, 0x41, + 0x34, 0x45, 0x34, 0x30, 0x42, 0x39, 0x42, 0x34, 0x31, 0x45, 0x33, 0x44, + 0x37, 0x30, 0x46, 0x32, 0x32, 0x38, 0x34, 0x30, 0x0a, 0x39, 0x34, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x34, 0x35, 0x34, + 0x42, 0x45, 0x43, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x38, 0x34, 0x38, 0x38, 0x44, 0x30, 0x33, 0x46, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x36, 0x38, 0x36, 0x46, 0x44, 0x44, 0x34, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x44, 0x46, + 0x36, 0x35, 0x43, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, + 0x30, 0x45, 0x41, 0x42, 0x39, 0x35, 0x30, 0x35, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x34, 0x35, 0x32, 0x46, 0x32, 0x39, 0x46, 0x34, + 0x34, 0x34, 0x30, 0x45, 0x36, 0x35, 0x35, 0x45, 0x46, 0x38, 0x43, 0x32, + 0x38, 0x36, 0x38, 0x34, 0x33, 0x34, 0x30, 0x42, 0x46, 0x38, 0x39, 0x34, + 0x45, 0x43, 0x43, 0x45, 0x43, 0x36, 0x46, 0x34, 0x43, 0x34, 0x30, 0x0a, + 0x39, 0x34, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x32, 0x46, 0x30, 0x35, 0x44, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x38, 0x33, 0x33, 0x44, 0x37, 0x43, 0x39, 0x33, 0x39, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x32, 0x37, 0x32, 0x39, + 0x37, 0x36, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, + 0x38, 0x37, 0x38, 0x41, 0x45, 0x37, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x42, 0x39, 0x32, 0x37, 0x39, 0x32, 0x33, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x42, 0x34, 0x42, 0x36, + 0x36, 0x30, 0x35, 0x30, 0x34, 0x30, 0x0a, 0x39, 0x34, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x45, 0x35, 0x43, 0x44, 0x44, + 0x32, 0x34, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x32, + 0x34, 0x30, 0x36, 0x45, 0x37, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x38, 0x35, 0x43, 0x33, 0x32, 0x30, 0x39, 0x34, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x43, 0x31, 0x37, 0x33, 0x34, + 0x39, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x43, 0x41, + 0x37, 0x44, 0x42, 0x36, 0x33, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x38, 0x43, 0x45, 0x39, 0x31, 0x43, 0x33, 0x33, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x43, 0x41, 0x38, 0x34, 0x36, + 0x41, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x42, + 0x33, 0x44, 0x36, 0x30, 0x44, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x43, 0x37, 0x41, 0x35, 0x46, 0x31, 0x46, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x31, 0x43, 0x35, 0x35, + 0x46, 0x31, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, + 0x33, 0x45, 0x34, 0x35, 0x36, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x41, 0x30, 0x46, 0x45, 0x39, 0x32, 0x44, 0x45, 0x35, 0x37, 0x34, + 0x30, 0x0a, 0x39, 0x34, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x42, 0x31, 0x32, 0x44, 0x31, 0x38, 0x33, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x39, 0x44, 0x31, 0x31, 0x36, + 0x33, 0x32, 0x34, 0x30, 0x45, 0x43, 0x46, 0x45, 0x41, 0x44, 0x36, 0x30, + 0x39, 0x30, 0x37, 0x38, 0x34, 0x33, 0x34, 0x30, 0x41, 0x36, 0x34, 0x33, + 0x35, 0x46, 0x42, 0x39, 0x45, 0x31, 0x31, 0x34, 0x33, 0x42, 0x34, 0x30, + 0x0a, 0x39, 0x34, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x38, 0x35, 0x36, 0x43, 0x42, 0x30, 0x33, 0x34, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x34, 0x35, 0x34, 0x35, 0x39, 0x43, 0x41, 0x35, + 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x42, 0x43, 0x45, + 0x30, 0x36, 0x45, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x30, 0x45, 0x30, 0x43, 0x39, 0x42, 0x34, 0x31, 0x45, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x34, 0x43, 0x44, 0x42, 0x38, 0x37, 0x42, 0x34, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x33, 0x43, + 0x46, 0x39, 0x42, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x46, 0x44, 0x30, 0x43, 0x32, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x32, 0x33, 0x41, 0x43, 0x41, 0x36, 0x46, 0x35, + 0x33, 0x34, 0x30, 0x0a, 0x39, 0x35, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x45, 0x34, 0x34, 0x38, 0x34, 0x35, 0x35, 0x34, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x41, 0x32, 0x41, 0x43, + 0x42, 0x35, 0x32, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x43, 0x35, 0x45, 0x45, 0x31, 0x44, 0x32, 0x43, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x41, 0x33, 0x34, 0x34, 0x35, 0x43, 0x42, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x45, 0x31, 0x37, 0x39, 0x41, + 0x43, 0x44, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x42, 0x42, 0x38, 0x36, 0x31, 0x32, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x34, 0x30, 0x31, 0x46, 0x46, 0x32, 0x31, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x39, 0x36, + 0x34, 0x45, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x37, 0x37, 0x31, 0x34, 0x41, 0x30, 0x33, 0x42, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x41, 0x31, 0x43, 0x33, 0x31, 0x42, 0x34, 0x44, + 0x34, 0x30, 0x0a, 0x39, 0x35, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x34, 0x32, 0x32, 0x35, 0x31, 0x37, 0x37, 0x34, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x41, 0x38, 0x31, 0x43, 0x31, 0x35, + 0x35, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x37, + 0x44, 0x43, 0x33, 0x39, 0x44, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x34, 0x36, 0x34, 0x41, 0x34, 0x42, 0x30, 0x34, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x45, 0x43, 0x41, 0x43, 0x32, + 0x42, 0x32, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x34, 0x35, + 0x44, 0x38, 0x46, 0x46, 0x33, 0x34, 0x46, 0x34, 0x30, 0x0a, 0x39, 0x35, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, 0x31, + 0x43, 0x35, 0x44, 0x32, 0x31, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x44, 0x43, 0x36, 0x42, 0x32, 0x33, 0x39, 0x37, 0x35, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, 0x42, 0x44, 0x33, + 0x42, 0x30, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x41, 0x43, 0x39, 0x31, + 0x35, 0x30, 0x35, 0x31, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x30, 0x32, 0x44, 0x31, 0x32, 0x33, 0x32, 0x34, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x33, 0x33, 0x38, 0x45, 0x43, 0x45, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x31, 0x33, + 0x32, 0x34, 0x35, 0x45, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x34, 0x36, 0x39, 0x41, 0x42, 0x30, 0x38, 0x34, 0x42, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x44, 0x35, 0x31, 0x38, + 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x42, 0x44, + 0x30, 0x42, 0x32, 0x43, 0x33, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x33, 0x34, 0x35, 0x43, 0x39, 0x34, 0x35, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x41, 0x34, 0x41, 0x36, 0x45, 0x31, + 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x34, 0x44, + 0x36, 0x31, 0x45, 0x46, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x34, 0x31, 0x38, 0x41, 0x35, 0x44, 0x39, 0x35, 0x33, 0x34, 0x30, + 0x0a, 0x39, 0x35, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x32, 0x36, 0x31, 0x46, 0x37, 0x33, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x45, 0x34, 0x43, 0x45, 0x41, 0x41, 0x34, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x32, 0x32, + 0x34, 0x30, 0x34, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x43, 0x46, 0x44, 0x36, 0x46, 0x44, 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x34, 0x41, 0x37, 0x44, 0x37, 0x33, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x38, 0x35, + 0x34, 0x41, 0x38, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x39, 0x35, 0x34, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x32, 0x39, 0x44, 0x43, 0x42, + 0x43, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, + 0x43, 0x34, 0x41, 0x41, 0x34, 0x45, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x42, 0x30, 0x35, 0x41, 0x33, 0x42, 0x46, 0x32, 0x34, 0x43, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x33, 0x46, 0x31, 0x41, + 0x33, 0x33, 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, + 0x38, 0x34, 0x44, 0x43, 0x44, 0x38, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x45, 0x46, 0x46, 0x42, 0x32, 0x44, 0x30, 0x41, + 0x34, 0x30, 0x0a, 0x39, 0x35, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x44, 0x30, 0x46, 0x45, 0x45, 0x46, 0x35, 0x34, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x31, 0x45, 0x30, 0x32, 0x36, + 0x43, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x30, + 0x45, 0x32, 0x46, 0x42, 0x43, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x41, 0x33, 0x42, 0x32, 0x32, 0x38, 0x37, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x38, 0x46, 0x44, 0x33, 0x36, 0x37, + 0x30, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x37, + 0x32, 0x37, 0x35, 0x34, 0x44, 0x31, 0x36, 0x34, 0x30, 0x42, 0x41, 0x41, + 0x37, 0x38, 0x33, 0x42, 0x37, 0x38, 0x38, 0x36, 0x36, 0x35, 0x30, 0x34, + 0x30, 0x43, 0x36, 0x39, 0x41, 0x34, 0x33, 0x39, 0x32, 0x30, 0x33, 0x39, + 0x30, 0x32, 0x45, 0x34, 0x30, 0x0a, 0x39, 0x35, 0x36, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x41, 0x30, 0x41, 0x38, 0x30, 0x34, 0x32, 0x35, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, + 0x39, 0x45, 0x37, 0x34, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x30, 0x46, 0x45, 0x31, 0x44, 0x34, 0x46, 0x32, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x38, 0x32, 0x42, 0x32, 0x44, 0x44, + 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x31, + 0x41, 0x37, 0x46, 0x35, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x30, 0x44, 0x41, 0x33, 0x42, 0x46, 0x35, 0x31, 0x33, 0x34, 0x30, + 0x0a, 0x39, 0x35, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, + 0x30, 0x38, 0x43, 0x46, 0x44, 0x43, 0x45, 0x35, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x36, 0x32, 0x33, 0x46, 0x33, 0x33, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x32, 0x46, 0x38, + 0x38, 0x43, 0x34, 0x33, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x38, 0x44, 0x45, 0x41, 0x35, 0x45, 0x43, 0x34, 0x35, 0x34, 0x30, 0x36, + 0x33, 0x45, 0x42, 0x31, 0x45, 0x42, 0x34, 0x43, 0x32, 0x31, 0x32, 0x34, + 0x39, 0x34, 0x30, 0x36, 0x45, 0x38, 0x36, 0x44, 0x30, 0x42, 0x41, 0x42, + 0x42, 0x45, 0x39, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x39, 0x35, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x44, 0x41, 0x38, 0x33, + 0x39, 0x37, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, + 0x37, 0x32, 0x41, 0x43, 0x38, 0x45, 0x33, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x43, 0x30, 0x35, 0x31, 0x46, 0x34, 0x37, 0x34, 0x32, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x33, 0x37, 0x45, 0x31, + 0x32, 0x41, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x43, + 0x44, 0x46, 0x41, 0x43, 0x30, 0x37, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x33, 0x42, 0x34, 0x42, 0x32, 0x35, 0x31, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x35, 0x33, 0x33, 0x31, + 0x30, 0x45, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, + 0x44, 0x45, 0x35, 0x44, 0x41, 0x31, 0x33, 0x30, 0x34, 0x30, 0x45, 0x39, + 0x37, 0x39, 0x31, 0x41, 0x39, 0x41, 0x36, 0x34, 0x35, 0x32, 0x34, 0x31, + 0x34, 0x30, 0x43, 0x34, 0x35, 0x36, 0x46, 0x35, 0x34, 0x42, 0x42, 0x33, + 0x36, 0x33, 0x34, 0x32, 0x34, 0x30, 0x0a, 0x39, 0x35, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x33, 0x41, 0x39, 0x31, 0x42, + 0x43, 0x33, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x35, + 0x31, 0x34, 0x37, 0x35, 0x36, 0x34, 0x45, 0x34, 0x30, 0x42, 0x35, 0x34, + 0x34, 0x46, 0x45, 0x35, 0x32, 0x41, 0x46, 0x37, 0x44, 0x33, 0x43, 0x34, + 0x30, 0x44, 0x38, 0x44, 0x37, 0x46, 0x44, 0x31, 0x39, 0x38, 0x30, 0x42, + 0x44, 0x34, 0x44, 0x34, 0x30, 0x0a, 0x39, 0x36, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x36, 0x44, 0x46, 0x41, 0x46, 0x42, + 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x33, 0x39, + 0x44, 0x45, 0x37, 0x30, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x35, 0x38, 0x44, 0x36, 0x44, 0x42, 0x33, 0x46, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x32, 0x44, 0x44, 0x45, 0x32, 0x33, + 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x33, 0x39, + 0x31, 0x41, 0x39, 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x43, 0x42, 0x36, 0x43, 0x42, 0x37, 0x45, 0x34, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x37, 0x42, 0x39, 0x36, 0x41, 0x45, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x34, 0x36, + 0x38, 0x35, 0x46, 0x46, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x38, 0x31, 0x45, 0x37, 0x35, 0x34, 0x33, 0x34, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x34, 0x41, 0x35, 0x45, 0x36, 0x42, + 0x34, 0x33, 0x34, 0x30, 0x0a, 0x39, 0x36, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x44, 0x43, 0x31, 0x42, 0x37, 0x45, 0x39, 0x45, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x33, 0x36, 0x35, + 0x36, 0x38, 0x38, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x30, 0x41, 0x35, 0x45, 0x36, 0x34, 0x42, 0x32, 0x44, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x41, 0x32, 0x43, 0x32, 0x38, 0x43, 0x34, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x44, + 0x37, 0x39, 0x32, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x38, 0x42, 0x39, 0x36, 0x37, 0x33, 0x41, 0x34, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x38, 0x34, 0x42, 0x38, 0x31, 0x43, 0x44, 0x33, + 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x46, 0x38, 0x38, + 0x46, 0x33, 0x38, 0x35, 0x35, 0x34, 0x30, 0x0a, 0x39, 0x36, 0x32, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x30, 0x38, 0x42, 0x30, + 0x37, 0x35, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x31, 0x36, 0x32, 0x30, 0x39, 0x43, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x38, 0x37, 0x34, 0x34, 0x36, 0x38, 0x33, 0x33, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x46, 0x33, 0x41, 0x39, + 0x42, 0x33, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, + 0x45, 0x42, 0x34, 0x38, 0x39, 0x32, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x34, 0x37, 0x46, 0x44, 0x42, 0x35, 0x34, 0x34, 0x41, + 0x34, 0x30, 0x0a, 0x39, 0x36, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x36, 0x33, 0x43, 0x31, 0x43, 0x44, 0x33, 0x45, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x43, 0x37, 0x32, 0x37, + 0x44, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x34, + 0x43, 0x36, 0x46, 0x43, 0x33, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x36, 0x32, 0x43, 0x45, 0x45, 0x31, 0x42, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x33, 0x44, 0x39, 0x46, + 0x32, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x43, 0x43, + 0x32, 0x32, 0x36, 0x31, 0x41, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x45, 0x38, 0x34, 0x43, 0x34, 0x33, 0x37, 0x35, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x37, 0x32, 0x39, 0x34, 0x45, + 0x30, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x46, + 0x37, 0x38, 0x31, 0x36, 0x43, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x30, 0x30, 0x33, 0x41, 0x36, 0x37, 0x32, 0x31, 0x37, 0x34, + 0x30, 0x0a, 0x39, 0x36, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x38, 0x34, 0x39, 0x36, 0x33, 0x41, 0x43, 0x34, 0x46, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x46, 0x34, 0x44, 0x45, 0x43, 0x39, 0x33, 0x31, + 0x34, 0x38, 0x34, 0x30, 0x43, 0x38, 0x32, 0x32, 0x39, 0x39, 0x39, 0x37, + 0x39, 0x43, 0x46, 0x37, 0x34, 0x38, 0x34, 0x30, 0x42, 0x30, 0x46, 0x31, + 0x42, 0x43, 0x44, 0x33, 0x30, 0x39, 0x33, 0x38, 0x34, 0x46, 0x34, 0x30, + 0x0a, 0x39, 0x36, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, + 0x30, 0x36, 0x43, 0x33, 0x38, 0x38, 0x41, 0x30, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x42, 0x34, 0x38, 0x32, 0x37, 0x31, 0x34, + 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x32, 0x37, 0x35, + 0x46, 0x35, 0x39, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x34, 0x33, 0x38, 0x38, 0x34, 0x36, 0x46, 0x34, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x30, 0x34, 0x31, 0x44, 0x33, 0x42, 0x42, 0x32, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x36, 0x41, 0x42, + 0x36, 0x44, 0x38, 0x32, 0x31, 0x34, 0x30, 0x0a, 0x39, 0x36, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x35, 0x39, 0x36, 0x31, + 0x36, 0x38, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x41, + 0x39, 0x30, 0x33, 0x44, 0x35, 0x35, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x38, 0x43, 0x44, 0x37, 0x34, 0x38, 0x42, 0x35, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x37, 0x44, 0x31, 0x34, + 0x35, 0x33, 0x33, 0x38, 0x34, 0x30, 0x0a, 0x39, 0x36, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x32, 0x44, 0x39, 0x46, 0x30, + 0x32, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x36, + 0x37, 0x38, 0x30, 0x31, 0x46, 0x32, 0x35, 0x34, 0x30, 0x45, 0x44, 0x37, + 0x30, 0x36, 0x44, 0x37, 0x44, 0x37, 0x34, 0x39, 0x42, 0x34, 0x30, 0x34, + 0x30, 0x42, 0x32, 0x46, 0x38, 0x31, 0x37, 0x34, 0x33, 0x35, 0x33, 0x36, + 0x30, 0x33, 0x34, 0x34, 0x30, 0x0a, 0x39, 0x36, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x43, 0x42, 0x30, 0x37, 0x37, 0x41, + 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x30, 0x39, + 0x39, 0x41, 0x42, 0x35, 0x34, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x46, 0x38, 0x33, 0x46, 0x42, 0x39, 0x38, 0x43, 0x35, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x34, 0x32, 0x37, 0x30, 0x35, + 0x33, 0x46, 0x34, 0x30, 0x36, 0x36, 0x31, 0x44, 0x33, 0x32, 0x35, 0x38, + 0x32, 0x30, 0x36, 0x30, 0x34, 0x44, 0x34, 0x30, 0x32, 0x46, 0x35, 0x32, + 0x33, 0x39, 0x31, 0x33, 0x45, 0x46, 0x39, 0x38, 0x35, 0x30, 0x34, 0x30, + 0x0a, 0x39, 0x36, 0x39, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x38, 0x38, 0x44, 0x30, 0x35, 0x42, 0x39, 0x34, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x43, 0x35, 0x42, 0x41, 0x34, 0x43, 0x34, 0x34, + 0x46, 0x34, 0x30, 0x35, 0x31, 0x35, 0x31, 0x44, 0x43, 0x45, 0x45, 0x41, + 0x41, 0x44, 0x45, 0x34, 0x31, 0x34, 0x30, 0x31, 0x46, 0x46, 0x45, 0x33, + 0x37, 0x42, 0x37, 0x34, 0x34, 0x31, 0x45, 0x34, 0x44, 0x34, 0x30, 0x0a, + 0x39, 0x37, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x43, 0x37, 0x38, 0x43, 0x46, 0x37, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x41, 0x30, 0x32, 0x43, 0x37, 0x33, 0x44, 0x31, 0x33, 0x42, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x41, 0x36, 0x31, 0x37, + 0x30, 0x46, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x32, + 0x37, 0x31, 0x39, 0x43, 0x30, 0x41, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x33, 0x38, 0x34, 0x44, 0x36, 0x42, 0x34, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x37, 0x32, 0x41, 0x43, + 0x46, 0x30, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x39, 0x37, 0x31, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x45, 0x33, 0x30, 0x34, 0x32, 0x46, + 0x42, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x36, + 0x42, 0x38, 0x45, 0x31, 0x32, 0x35, 0x37, 0x34, 0x30, 0x41, 0x34, 0x45, + 0x31, 0x32, 0x45, 0x31, 0x30, 0x35, 0x46, 0x44, 0x36, 0x35, 0x33, 0x34, + 0x30, 0x45, 0x43, 0x33, 0x36, 0x39, 0x37, 0x46, 0x41, 0x34, 0x41, 0x30, + 0x33, 0x35, 0x34, 0x34, 0x30, 0x0a, 0x39, 0x37, 0x32, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x45, 0x34, 0x41, 0x46, 0x34, 0x42, 0x31, + 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x41, 0x35, + 0x35, 0x34, 0x34, 0x44, 0x34, 0x36, 0x34, 0x30, 0x43, 0x43, 0x42, 0x39, + 0x43, 0x44, 0x44, 0x44, 0x33, 0x31, 0x44, 0x33, 0x34, 0x36, 0x34, 0x30, + 0x42, 0x30, 0x38, 0x32, 0x35, 0x38, 0x42, 0x38, 0x30, 0x39, 0x39, 0x46, + 0x33, 0x34, 0x34, 0x30, 0x0a, 0x39, 0x37, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x42, 0x43, 0x32, 0x42, 0x45, 0x42, 0x45, 0x39, 0x34, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x46, 0x42, 0x44, + 0x34, 0x35, 0x30, 0x32, 0x30, 0x34, 0x30, 0x34, 0x42, 0x43, 0x34, 0x30, + 0x45, 0x34, 0x42, 0x42, 0x31, 0x34, 0x31, 0x34, 0x31, 0x34, 0x30, 0x42, + 0x36, 0x32, 0x45, 0x41, 0x41, 0x36, 0x44, 0x43, 0x41, 0x44, 0x30, 0x33, + 0x41, 0x34, 0x30, 0x0a, 0x39, 0x37, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x32, 0x38, 0x45, 0x46, 0x44, 0x44, 0x33, 0x41, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x41, 0x30, 0x42, 0x44, + 0x35, 0x33, 0x33, 0x30, 0x34, 0x30, 0x32, 0x39, 0x35, 0x34, 0x41, 0x41, + 0x37, 0x32, 0x43, 0x45, 0x36, 0x44, 0x33, 0x39, 0x34, 0x30, 0x36, 0x38, + 0x37, 0x41, 0x37, 0x37, 0x37, 0x37, 0x44, 0x31, 0x33, 0x44, 0x33, 0x35, + 0x34, 0x30, 0x0a, 0x39, 0x37, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x45, 0x37, 0x30, 0x33, 0x44, 0x45, 0x33, 0x42, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x41, 0x30, 0x39, 0x43, 0x39, 0x37, + 0x43, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x45, + 0x32, 0x44, 0x32, 0x46, 0x32, 0x33, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x31, 0x42, 0x37, 0x31, 0x45, 0x32, 0x34, 0x43, 0x34, + 0x30, 0x31, 0x30, 0x44, 0x32, 0x31, 0x46, 0x33, 0x39, 0x39, 0x32, 0x34, + 0x35, 0x34, 0x42, 0x34, 0x30, 0x33, 0x30, 0x42, 0x38, 0x38, 0x36, 0x43, + 0x36, 0x32, 0x38, 0x32, 0x30, 0x34, 0x43, 0x34, 0x30, 0x0a, 0x39, 0x37, + 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x36, 0x34, + 0x36, 0x39, 0x42, 0x43, 0x32, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x45, 0x43, 0x30, 0x38, 0x42, 0x46, 0x32, 0x37, 0x34, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x36, 0x35, 0x34, 0x41, 0x30, 0x34, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x43, 0x44, 0x31, + 0x32, 0x36, 0x46, 0x46, 0x34, 0x36, 0x34, 0x30, 0x33, 0x37, 0x36, 0x36, + 0x43, 0x35, 0x44, 0x33, 0x38, 0x33, 0x35, 0x42, 0x34, 0x43, 0x34, 0x30, + 0x37, 0x31, 0x31, 0x42, 0x42, 0x32, 0x34, 0x42, 0x30, 0x32, 0x32, 0x38, + 0x34, 0x43, 0x34, 0x30, 0x0a, 0x39, 0x37, 0x37, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x41, 0x38, 0x33, 0x37, 0x38, 0x46, 0x33, 0x30, 0x33, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x35, 0x32, 0x30, + 0x37, 0x37, 0x35, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x34, 0x43, 0x32, 0x46, 0x44, 0x41, 0x33, 0x34, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x44, 0x42, 0x31, 0x31, 0x31, 0x34, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x36, 0x32, 0x37, + 0x41, 0x30, 0x45, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x32, 0x44, 0x45, 0x39, 0x38, 0x45, 0x31, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x35, 0x43, 0x31, 0x44, 0x45, 0x30, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x36, 0x39, 0x33, + 0x37, 0x41, 0x35, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x38, 0x31, 0x42, 0x32, 0x33, 0x46, 0x30, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x41, 0x46, 0x37, 0x39, 0x34, 0x39, 0x37, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x39, 0x33, 0x45, + 0x35, 0x41, 0x39, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x42, 0x39, 0x37, 0x32, 0x34, 0x33, 0x35, 0x37, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x39, 0x41, 0x36, 0x42, 0x32, 0x33, + 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x43, 0x38, 0x33, 0x31, + 0x33, 0x37, 0x38, 0x35, 0x38, 0x34, 0x30, 0x0a, 0x39, 0x37, 0x38, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x43, 0x30, 0x45, 0x34, 0x34, + 0x35, 0x44, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, + 0x35, 0x31, 0x33, 0x32, 0x34, 0x43, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x36, 0x33, 0x32, 0x46, 0x33, 0x46, 0x34, 0x46, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x42, 0x31, 0x31, 0x33, + 0x34, 0x44, 0x31, 0x46, 0x34, 0x30, 0x0a, 0x39, 0x37, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x33, 0x45, 0x37, 0x30, + 0x44, 0x32, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x34, + 0x38, 0x43, 0x39, 0x45, 0x38, 0x34, 0x41, 0x34, 0x30, 0x39, 0x46, 0x43, + 0x35, 0x39, 0x44, 0x30, 0x41, 0x30, 0x37, 0x38, 0x32, 0x34, 0x30, 0x34, + 0x30, 0x35, 0x42, 0x39, 0x36, 0x43, 0x44, 0x33, 0x45, 0x41, 0x39, 0x41, + 0x45, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x39, 0x38, 0x30, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x41, 0x37, 0x32, 0x45, 0x33, 0x45, + 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x46, 0x43, + 0x37, 0x36, 0x43, 0x34, 0x34, 0x46, 0x34, 0x30, 0x34, 0x39, 0x31, 0x44, + 0x31, 0x42, 0x38, 0x35, 0x46, 0x46, 0x36, 0x33, 0x34, 0x41, 0x34, 0x30, + 0x41, 0x43, 0x41, 0x41, 0x39, 0x41, 0x44, 0x43, 0x39, 0x30, 0x41, 0x43, + 0x33, 0x38, 0x34, 0x30, 0x0a, 0x39, 0x38, 0x31, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x37, 0x34, 0x45, 0x33, 0x44, 0x33, + 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, 0x34, 0x41, 0x37, 0x41, + 0x38, 0x32, 0x43, 0x34, 0x31, 0x34, 0x30, 0x33, 0x38, 0x33, 0x35, 0x38, + 0x38, 0x42, 0x45, 0x45, 0x30, 0x35, 0x43, 0x35, 0x33, 0x34, 0x30, 0x36, + 0x33, 0x44, 0x36, 0x30, 0x39, 0x42, 0x44, 0x33, 0x32, 0x39, 0x38, 0x34, + 0x44, 0x34, 0x30, 0x0a, 0x39, 0x38, 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x32, 0x36, 0x39, 0x32, 0x35, 0x41, 0x36, 0x35, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x38, 0x32, 0x38, 0x41, 0x36, + 0x30, 0x43, 0x33, 0x42, 0x34, 0x30, 0x36, 0x30, 0x42, 0x41, 0x34, 0x31, + 0x35, 0x41, 0x45, 0x44, 0x42, 0x37, 0x35, 0x32, 0x34, 0x30, 0x34, 0x39, + 0x31, 0x33, 0x36, 0x44, 0x33, 0x38, 0x30, 0x35, 0x36, 0x30, 0x34, 0x32, + 0x34, 0x30, 0x0a, 0x39, 0x38, 0x33, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x38, 0x46, 0x35, 0x35, 0x31, 0x30, 0x44, 0x34, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x44, 0x44, 0x38, 0x42, + 0x43, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x36, 0x31, + 0x42, 0x45, 0x33, 0x34, 0x43, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x38, 0x45, 0x45, 0x34, 0x32, 0x34, 0x37, 0x35, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x32, 0x31, 0x38, + 0x39, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, + 0x35, 0x41, 0x32, 0x35, 0x45, 0x46, 0x30, 0x33, 0x46, 0x0a, 0x39, 0x38, + 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x34, 0x39, 0x39, + 0x45, 0x34, 0x44, 0x33, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x43, 0x42, 0x45, 0x39, 0x44, 0x41, 0x46, 0x34, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x46, 0x31, 0x37, 0x44, 0x32, 0x36, + 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x43, 0x36, 0x37, + 0x31, 0x37, 0x43, 0x35, 0x34, 0x37, 0x34, 0x30, 0x0a, 0x39, 0x38, 0x35, + 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, + 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x32, 0x33, 0x31, + 0x43, 0x38, 0x41, 0x31, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x34, 0x34, 0x46, 0x31, 0x38, 0x38, 0x42, 0x34, 0x37, 0x34, 0x30, 0x35, + 0x35, 0x35, 0x37, 0x46, 0x41, 0x38, 0x39, 0x38, 0x43, 0x42, 0x39, 0x33, + 0x34, 0x34, 0x30, 0x35, 0x37, 0x44, 0x44, 0x31, 0x43, 0x31, 0x38, 0x41, + 0x30, 0x31, 0x32, 0x34, 0x45, 0x34, 0x30, 0x0a, 0x39, 0x38, 0x36, 0x2c, + 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x46, 0x46, 0x41, 0x42, + 0x33, 0x36, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x45, + 0x33, 0x42, 0x36, 0x35, 0x42, 0x43, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x45, 0x45, 0x34, 0x45, 0x41, 0x45, 0x42, 0x35, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x41, 0x39, + 0x33, 0x45, 0x35, 0x33, 0x34, 0x30, 0x0a, 0x39, 0x38, 0x37, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x45, 0x34, 0x32, 0x43, 0x45, 0x45, + 0x33, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x34, + 0x31, 0x34, 0x38, 0x31, 0x35, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x44, 0x38, 0x33, 0x44, 0x41, 0x45, 0x33, 0x37, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x35, 0x45, 0x42, 0x31, 0x33, + 0x30, 0x35, 0x32, 0x34, 0x30, 0x0a, 0x39, 0x38, 0x38, 0x2c, 0x30, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x45, 0x32, 0x30, 0x33, 0x30, + 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x45, 0x39, + 0x32, 0x42, 0x37, 0x32, 0x35, 0x32, 0x34, 0x30, 0x44, 0x36, 0x30, 0x44, + 0x42, 0x33, 0x36, 0x30, 0x31, 0x31, 0x32, 0x45, 0x34, 0x45, 0x34, 0x30, + 0x30, 0x46, 0x36, 0x42, 0x32, 0x38, 0x35, 0x45, 0x35, 0x46, 0x30, 0x33, + 0x35, 0x32, 0x34, 0x30, 0x0a, 0x39, 0x38, 0x39, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x37, 0x45, 0x39, 0x39, 0x30, + 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x43, 0x44, 0x42, 0x45, + 0x42, 0x32, 0x39, 0x34, 0x31, 0x34, 0x30, 0x37, 0x38, 0x35, 0x35, 0x44, + 0x46, 0x44, 0x33, 0x37, 0x33, 0x35, 0x31, 0x33, 0x36, 0x34, 0x30, 0x35, + 0x39, 0x45, 0x35, 0x38, 0x37, 0x35, 0x36, 0x39, 0x33, 0x44, 0x34, 0x34, + 0x46, 0x34, 0x30, 0x0a, 0x39, 0x39, 0x30, 0x2c, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x37, 0x31, 0x30, 0x46, 0x31, 0x39, 0x34, 0x37, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x34, 0x37, 0x44, 0x30, + 0x45, 0x42, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x46, 0x43, 0x32, 0x30, 0x45, 0x32, 0x41, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x38, 0x31, 0x33, 0x44, 0x35, 0x43, 0x39, 0x34, 0x41, + 0x34, 0x30, 0x39, 0x42, 0x37, 0x39, 0x34, 0x34, 0x30, 0x41, 0x39, 0x32, + 0x30, 0x46, 0x34, 0x30, 0x34, 0x30, 0x34, 0x38, 0x33, 0x32, 0x30, 0x35, + 0x30, 0x39, 0x38, 0x41, 0x37, 0x33, 0x34, 0x31, 0x34, 0x30, 0x0a, 0x39, + 0x39, 0x31, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x45, 0x37, + 0x44, 0x42, 0x43, 0x42, 0x33, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x43, 0x37, 0x36, 0x42, 0x38, 0x34, 0x45, 0x42, 0x33, + 0x46, 0x39, 0x44, 0x35, 0x30, 0x35, 0x38, 0x33, 0x31, 0x37, 0x38, 0x32, + 0x32, 0x35, 0x31, 0x34, 0x30, 0x38, 0x30, 0x33, 0x37, 0x39, 0x33, 0x42, + 0x35, 0x42, 0x37, 0x43, 0x31, 0x33, 0x46, 0x34, 0x30, 0x0a, 0x39, 0x39, + 0x32, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x30, 0x35, 0x37, + 0x36, 0x33, 0x30, 0x36, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x46, 0x38, 0x46, 0x36, 0x39, 0x43, 0x34, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x43, 0x46, 0x31, 0x46, 0x31, 0x38, + 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x32, 0x36, 0x31, + 0x44, 0x38, 0x38, 0x36, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x42, 0x41, 0x41, 0x31, 0x30, 0x32, 0x41, 0x30, 0x35, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x30, 0x41, 0x37, 0x41, 0x38, 0x39, + 0x31, 0x31, 0x34, 0x30, 0x0a, 0x39, 0x39, 0x33, 0x2c, 0x30, 0x31, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x41, 0x46, 0x39, 0x44, 0x41, 0x45, 0x31, 0x35, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x38, 0x35, 0x34, 0x30, + 0x34, 0x46, 0x42, 0x34, 0x43, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x38, 0x41, 0x37, 0x32, 0x42, 0x31, 0x35, 0x34, 0x41, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x34, 0x45, 0x39, 0x38, 0x38, 0x32, 0x32, + 0x31, 0x34, 0x30, 0x33, 0x43, 0x33, 0x35, 0x39, 0x36, 0x45, 0x43, 0x30, + 0x37, 0x30, 0x42, 0x34, 0x44, 0x34, 0x30, 0x46, 0x43, 0x42, 0x41, 0x37, + 0x41, 0x45, 0x42, 0x41, 0x32, 0x30, 0x32, 0x33, 0x35, 0x34, 0x30, 0x0a, + 0x39, 0x39, 0x34, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, + 0x37, 0x45, 0x43, 0x35, 0x41, 0x42, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x30, 0x45, 0x37, 0x36, 0x37, 0x44, 0x43, 0x33, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x36, 0x46, 0x41, 0x38, 0x33, + 0x37, 0x38, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, + 0x42, 0x44, 0x41, 0x33, 0x33, 0x39, 0x34, 0x44, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x44, 0x38, 0x36, 0x45, 0x43, 0x36, 0x43, 0x43, 0x34, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x45, 0x39, 0x41, + 0x34, 0x33, 0x30, 0x46, 0x34, 0x30, 0x43, 0x45, 0x36, 0x36, 0x33, 0x32, + 0x43, 0x39, 0x39, 0x46, 0x43, 0x32, 0x35, 0x32, 0x34, 0x30, 0x33, 0x36, + 0x30, 0x46, 0x42, 0x46, 0x41, 0x31, 0x33, 0x31, 0x37, 0x35, 0x34, 0x46, + 0x34, 0x30, 0x0a, 0x39, 0x39, 0x35, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x42, 0x34, 0x34, 0x36, 0x30, 0x41, 0x37, 0x31, 0x34, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x45, 0x30, 0x45, 0x32, 0x36, 0x30, 0x30, + 0x38, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x46, + 0x31, 0x37, 0x37, 0x30, 0x34, 0x30, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x36, 0x36, 0x41, 0x38, 0x30, 0x31, 0x42, 0x35, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, 0x30, 0x31, 0x41, 0x30, 0x32, 0x33, + 0x38, 0x32, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x45, + 0x41, 0x33, 0x32, 0x43, 0x37, 0x34, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x46, 0x38, 0x42, 0x34, 0x30, 0x42, 0x33, 0x42, 0x33, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x32, 0x36, 0x35, 0x30, 0x34, + 0x43, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x45, + 0x31, 0x31, 0x42, 0x37, 0x36, 0x34, 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x44, 0x30, 0x32, 0x39, 0x38, 0x30, 0x32, 0x41, 0x34, 0x35, 0x34, + 0x30, 0x0a, 0x39, 0x39, 0x36, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x36, 0x30, 0x33, 0x36, 0x32, 0x35, 0x46, 0x35, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x35, 0x45, 0x39, 0x34, 0x37, 0x30, + 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x30, 0x39, 0x46, + 0x42, 0x43, 0x39, 0x43, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x44, 0x38, 0x38, 0x35, 0x38, 0x39, 0x36, 0x41, 0x34, 0x37, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x45, 0x38, 0x36, 0x33, 0x42, 0x39, 0x39, 0x45, + 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x32, 0x45, + 0x33, 0x32, 0x46, 0x42, 0x31, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x31, 0x42, 0x36, 0x41, 0x32, 0x31, 0x31, 0x35, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x43, 0x43, 0x32, 0x30, 0x32, 0x33, 0x31, 0x43, + 0x34, 0x41, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x46, + 0x37, 0x46, 0x43, 0x45, 0x32, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x41, 0x46, 0x45, 0x42, 0x31, 0x45, 0x45, 0x33, 0x46, + 0x0a, 0x39, 0x39, 0x37, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x42, + 0x30, 0x33, 0x34, 0x32, 0x39, 0x44, 0x36, 0x32, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x43, 0x46, 0x39, 0x42, 0x33, 0x43, 0x38, 0x35, + 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x44, 0x46, 0x31, + 0x45, 0x31, 0x37, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x32, 0x38, 0x33, 0x30, 0x45, 0x36, 0x31, 0x43, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x46, 0x30, 0x45, 0x46, 0x44, 0x45, 0x33, 0x35, 0x35, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x35, + 0x41, 0x31, 0x43, 0x44, 0x34, 0x33, 0x46, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x43, 0x36, 0x34, 0x32, 0x44, 0x39, 0x39, 0x34, 0x42, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x34, 0x45, 0x30, 0x42, 0x39, 0x41, 0x36, 0x34, + 0x42, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x37, 0x37, 0x41, + 0x36, 0x32, 0x46, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x41, + 0x30, 0x44, 0x35, 0x31, 0x42, 0x38, 0x35, 0x35, 0x36, 0x34, 0x30, 0x0a, + 0x39, 0x39, 0x38, 0x2c, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x43, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, + 0x46, 0x36, 0x45, 0x44, 0x44, 0x46, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x45, 0x36, 0x33, 0x46, 0x39, 0x43, 0x41, 0x30, 0x35, 0x35, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x44, 0x37, 0x43, + 0x30, 0x35, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x38, 0x35, 0x38, 0x33, 0x39, 0x43, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x43, 0x30, 0x41, 0x41, 0x45, 0x35, 0x45, 0x42, 0x30, 0x44, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x41, 0x32, 0x39, 0x45, 0x36, + 0x41, 0x38, 0x35, 0x31, 0x34, 0x30, 0x0a, 0x39, 0x39, 0x39, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x43, 0x38, 0x34, 0x33, 0x45, 0x30, + 0x39, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x43, 0x30, 0x34, + 0x38, 0x37, 0x44, 0x42, 0x46, 0x32, 0x34, 0x34, 0x30, 0x35, 0x30, 0x33, + 0x44, 0x38, 0x44, 0x36, 0x30, 0x32, 0x38, 0x32, 0x34, 0x34, 0x39, 0x34, + 0x30, 0x35, 0x36, 0x41, 0x42, 0x45, 0x43, 0x44, 0x46, 0x34, 0x45, 0x32, + 0x42, 0x34, 0x30, 0x34, 0x30, 0x0a, 0x31, 0x30, 0x30, 0x30, 0x2c, 0x30, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x43, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x46, 0x43, 0x41, 0x39, 0x30, 0x37, 0x42, + 0x37, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x32, + 0x32, 0x39, 0x34, 0x43, 0x33, 0x34, 0x46, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x45, 0x38, 0x35, 0x45, 0x41, 0x35, 0x36, 0x32, 0x34, 0x41, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x43, 0x30, 0x34, 0x32, 0x34, 0x43, + 0x42, 0x35, 0x38, 0x34, 0x30, 0x42, 0x38, 0x34, 0x41, 0x37, 0x33, 0x37, + 0x44, 0x36, 0x41, 0x42, 0x33, 0x34, 0x37, 0x34, 0x30, 0x45, 0x37, 0x36, + 0x37, 0x44, 0x43, 0x42, 0x42, 0x42, 0x30, 0x33, 0x33, 0x35, 0x35, 0x34, + 0x30, 0x0a +}; +unsigned int ways1000_csv_len = 125066; diff --git a/test/sql/tnpoint.test b/test/sql/tnpoint.test new file mode 100644 index 00000000..520ed961 --- /dev/null +++ b/test/sql/tnpoint.test @@ -0,0 +1,226 @@ +# name: test/sql/tnpoint.test +# description: Core tnpoint type port — construction, text/EWKT/MFJSON I/O +# and basic accessors. The tnpoint value is an Npoint +# (route id + relative position), a network-relative +# reference resolved against the embedded ways CSV. +# group: [sql] + +require mobilityduck + +# Test tnpoint constructor with parentheses +query I +SELECT asText(tnpoint('Npoint(1, 0.5)@2000-01-01')); +---- +NPoint(1,0.5)@2000-01-01 00:00:00+01 + +# Test tnpoint constructor without parentheses +query I +SELECT asText(tnpoint 'Npoint(1, 0.5)@2000-01-01'); +---- +NPoint(1,0.5)@2000-01-01 00:00:00+01 + +# Test asText with continuous sequence +query I +SELECT asText(tnpoint '[Npoint(1, 0.2)@2000-01-01, Npoint(1, 0.4)@2000-01-02, Npoint(1, 0.5)@2000-01-03]'); +---- +[NPoint(1,0.2)@2000-01-01 00:00:00+01, NPoint(1,0.4)@2000-01-02 00:00:00+01, NPoint(1,0.5)@2000-01-03 00:00:00+01] + +# Test asText with discrete sequence +query I +SELECT asText(tnpoint '{Npoint(1, 0.3)@2000-01-01, Npoint(1, 0.5)@2000-01-02}'); +---- +{NPoint(1,0.3)@2000-01-01 00:00:00+01, NPoint(1,0.5)@2000-01-02 00:00:00+01} + +# Test asEWKT — npoints carry the ways-network SRID (5676), which EWKT +# prefixes (asText omits it). +query I +SELECT asEWKT(tnpoint 'Npoint(1, 0.5)@2000-01-01'); +---- +SRID=5676;NPoint(1,0.5)@2000-01-01 00:00:00+01 + +# Test value-and-timestamp constructor round-trips +query I +SELECT tnpoint('Npoint(1, 0.5)', timestamptz '2012-01-01 08:00:00') + = tnpoint 'Npoint(1, 0.5)@2012-01-01 08:00:00'; +---- +true + +# Test value-and-tstzspan constructor produces a 2-instant sequence +query I +SELECT numInstants(tnpoint('Npoint(1, 0.5)', tstzspan '[2001-01-01, 2001-01-02]')); +---- +2 + +# Test value-and-tstzspan constructor with linear interpolation +query I +SELECT interp(tnpoint('Npoint(1, 0.5)', tstzspan '[2001-01-01, 2001-01-02]', 'linear')); +---- +Linear + +# Test tnpointSeq with linear interpolation and bounds +query I +SELECT asText(tnpointSeq(ARRAY[tnpoint 'Npoint(1, 0.2)@2001-01-01', 'Npoint(1, 0.4)@2001-01-02'], 'linear', 'true','true')); +---- +[NPoint(1,0.2)@2001-01-01 00:00:00+01, NPoint(1,0.4)@2001-01-02 00:00:00+01] + +# Test tnpointSeq with default parameters +query I +SELECT asText(tnpointSeq(ARRAY[tnpoint 'Npoint(1, 0.2)@2001-01-01', 'Npoint(1, 0.4)@2001-01-02'])); +---- +[NPoint(1,0.2)@2001-01-01 00:00:00+01, NPoint(1,0.4)@2001-01-02 00:00:00+01] + +# Test tnpointSeq with discrete interpolation +query I +SELECT asText(tnpointSeq(ARRAY[tnpoint 'Npoint(1, 0.2)@2001-01-01', 'Npoint(1, 0.4)@2001-01-02'], 'discrete')); +---- +{NPoint(1,0.2)@2001-01-01 00:00:00+01, NPoint(1,0.4)@2001-01-02 00:00:00+01} + +# Test MFJSON input via the FromMFJSON constructor reconstructs the value +# (the #951 MFJSON schema: typestring MovingNetworkPoint, value object +# {"route":rid,"position":pos}, routed through the generic dispatch). +query I +SELECT tnpointFromMFJSON('{"type":"MovingNetworkPoint","values":[{"route":1,"position":0.5}],"datetimes":["2000-01-01T00:00:00+01"],"interpolation":"None"}') + = tnpoint 'Npoint(1, 0.5)@2000-01-01'; +---- +true + +# Test MFJSON input round-trip for a continuous sequence +query I +SELECT tnpointFromMFJSON('{"type":"MovingNetworkPoint","values":[{"route":1,"position":0.2},{"route":1,"position":0.4}],"datetimes":["2000-01-01T00:00:00+01","2000-01-02T00:00:00+01"],"lower_inc":true,"upper_inc":true,"interpolation":"Linear"}') + = tnpoint '[Npoint(1, 0.2)@2000-01-01, Npoint(1, 0.4)@2000-01-02]'; +---- +true + +# Test tnpointFromText constructor +query I +SELECT tnpointFromText('Npoint(1, 0.5)@2000-01-01') + = tnpoint 'Npoint(1, 0.5)@2000-01-01'; +---- +true + +# Test tnpointFromEWKT constructor +query I +SELECT tnpointFromEWKT('Npoint(1, 0.5)@2000-01-01') + = tnpoint 'Npoint(1, 0.5)@2000-01-01'; +---- +true + +# Test timeSpan function +query I +SELECT timeSpan(tnpoint 'Npoint(1, 0.5)@2023-01-01 10:00:00+00'); +---- +[2023-01-01 11:00:00+01, 2023-01-01 11:00:00+01] + +# Test tnpointInst function +query I +SELECT asText(tnpointInst(tnpoint 'Npoint(1, 0.5)@2023-01-01 10:00:00+00')); +---- +NPoint(1,0.5)@2023-01-01 11:00:00+01 + +# Test setInterp with discrete interpolation +query I +SELECT asEWKT(setInterp(tnpoint 'Npoint(1, 0.5)@2000-01-01', 'discrete')); +---- +SRID=5676;{NPoint(1,0.5)@2000-01-01 00:00:00+01} + +# Test merge function +query I +SELECT asText(merge(tnpoint 'Npoint(1, 0.5)@2000-01-01', tnpoint 'Npoint(1, 0.5)@2000-01-02')); +---- +{NPoint(1,0.5)@2000-01-01 00:00:00+01, NPoint(1,0.5)@2000-01-02 00:00:00+01} + +# Test tempSubtype with instant +query I +SELECT tempSubtype(tnpoint 'Npoint(1, 0.5)@2000-01-01'); +---- +Instant + +# Test tempSubtype with discrete sequence +query I +SELECT tempSubtype(tnpoint '{Npoint(1, 0.3)@2000-01-01, Npoint(1, 0.5)@2000-01-02}'); +---- +Sequence + +# Test tempSubtype with continuous sequence +query I +SELECT tempSubtype(tnpoint '[Npoint(1, 0.2)@2000-01-01, Npoint(1, 0.4)@2000-01-02]'); +---- +Sequence + +# Test tempSubtype with sequence set +query I +SELECT tempSubtype(tnpoint '{[Npoint(1, 0.2)@2000-01-01, Npoint(1, 0.4)@2000-01-02],[Npoint(2, 0.6)@2000-01-03, Npoint(2, 0.6)@2000-01-04]}'); +---- +SequenceSet + +# Test memSize is positive +query I +SELECT memSize(tnpoint 'Npoint(1, 0.5)@2000-01-01') > 0; +---- +true + +# Test interp accessor +query I +SELECT interp(tnpoint '[Npoint(1, 0.2)@2000-01-01, Npoint(1, 0.4)@2000-01-02]'); +---- +Linear + +# Test getValue function returns the npoint value text +query I +SELECT getValue(tnpoint 'Npoint(1, 0.5)@2000-01-01'); +---- +NPoint(1,0.5) + +# Test startValue function +query I +SELECT startValue(tnpoint '[Npoint(1, 0.2)@2000-01-01, Npoint(1, 0.4)@2000-01-02, Npoint(1, 0.5)@2000-01-03]'); +---- +NPoint(1,0.2) + +# Test endValue function +query I +SELECT endValue(tnpoint '[Npoint(1, 0.2)@2000-01-01, Npoint(1, 0.4)@2000-01-02, Npoint(1, 0.5)@2000-01-03]'); +---- +NPoint(1,0.5) + +# Test route accessor is the single route the network point traverses +query I +SELECT route(tnpoint 'Npoint(3, 0.5)@2000-01-01'); +---- +3 + +# Test startInstant +query I +SELECT asText(startInstant(tnpoint '[Npoint(1, 0.2)@2000-01-01, Npoint(1, 0.4)@2000-01-02]')); +---- +NPoint(1,0.2)@2000-01-01 00:00:00+01 + +# Test endInstant +query I +SELECT asText(endInstant(tnpoint '[Npoint(1, 0.2)@2000-01-01, Npoint(1, 0.4)@2000-01-02]')); +---- +NPoint(1,0.4)@2000-01-02 00:00:00+01 + +# Test instantN +query I +SELECT asText(instantN(tnpoint '[Npoint(1, 0.2)@2000-01-01, Npoint(1, 0.4)@2000-01-02]', 1)); +---- +NPoint(1,0.2)@2000-01-01 00:00:00+01 + +# Test getTimestamp function +query I +SELECT getTimestamp(tnpoint 'Npoint(1, 0.5)@2023-01-01 10:00:00+00'); +---- +2023-01-01 11:00:00+01 + +# Test numInstants generic accessor +query I +SELECT numInstants(tnpoint '[Npoint(1, 0.2)@2000-01-01, Npoint(1, 0.4)@2000-01-02, Npoint(1, 0.5)@2000-01-03]'); +---- +3 + +# Test duration generic accessor +query I +SELECT duration(tnpoint '[Npoint(1, 0.2)@2000-01-01, Npoint(1, 0.4)@2000-01-03]'); +---- +2 days From c73d10319448b614903d8ed6160e2b979679134e Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Tue, 26 May 2026 01:54:18 +0200 Subject: [PATCH 4/6] Fold the core tpose type port (#151) Brings the temporal pose (tpose) type into the accumulate: construction, text/EWKT/MFJSON/WKB I/O, casts, and accessors, registered in LoadInternal after the tnpoint surface. Fixes applied on top of the #151 branch: - getValue/startValue/endValue value executors renamed to tpose-unique names (Tpose_{get,start,end}_value) and rendered via pose_as_text (WKT form "Pose(POINT(x y),r)"). Generic names collide with the other geo .cpp (ODR violation -> geometry renderer -> "Unknown geometry type: 0"); pose_out emits the HexWKB/uppercase "POSE (...)" form, not what asText/getValue want. - Close the output-serialization gap the #151 test exercises but the port omitted: register asMFJSON (via temporal_as_mfjson) and asBinary / asEWKB / asHexWKB / asHexEWKB (via temporal_as_wkb / temporal_as_hexwkb), with tpose-unique exec names. MobilityDB exposes all of these for tpose. - Fix the setInterp-to-discrete test: a multi-instant continuous sequence cannot be discretized (MEOS errors); lift an instant instead, matching MobilityDB's 102_tpose reference. Full sqllogictest suite green: 1830 assertions across 79 test cases. (cherry picked from commit ec74d588ac5c3c81f93955feabafaf257bc17394) --- CMakeLists.txt | 8 + src/geo/tpose.cpp | 1508 ++++++++++++++++++++++++++++++++ src/geo/tpose_in_out.cpp | 432 +++++++++ src/include/geo/tpose.hpp | 29 + src/mobilityduck_extension.cpp | 11 + test/sql/tpose.test | 206 +++++ 6 files changed, 2194 insertions(+) create mode 100644 src/geo/tpose.cpp create mode 100644 src/geo/tpose_in_out.cpp create mode 100644 src/include/geo/tpose.hpp create mode 100644 test/sql/tpose.test diff --git a/CMakeLists.txt b/CMakeLists.txt index 2a6aed37..93c49957 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -115,6 +115,14 @@ if(NPOINT) src/geo/tnpoint_in_out.cpp) endif() +option(POSE "Build the tpose temporal type" ON) +if(POSE) + add_definitions(-DPOSE=1) + list(APPEND EXTENSION_SOURCES + src/geo/tpose.cpp + src/geo/tpose_in_out.cpp) +endif() + build_static_extension(${TARGET_NAME} ${EXTENSION_SOURCES}) build_loadable_extension(${TARGET_NAME} "" ${EXTENSION_SOURCES}) diff --git a/src/geo/tpose.cpp b/src/geo/tpose.cpp new file mode 100644 index 00000000..34d7cd3b --- /dev/null +++ b/src/geo/tpose.cpp @@ -0,0 +1,1508 @@ +#include "geo/tpose.hpp" +#include "geo/tgeompoint_functions.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include "duckdb/common/extension_type_info.hpp" +#include +#include +#include +#include "temporal/spanset.hpp" +#include "temporal/set.hpp" +#include "temporal/temporal_functions.hpp" +#include "geo/stbox.hpp" +#include "geo/geoset.hpp" +#include +#include "geo_util.hpp" +#include "spatial/spatial_types.hpp" +#include "mobilityduck/meos_exec_serial.hpp" + +extern "C" { + #include + #include + #include + #include + #include +} + + +namespace duckdb { + +LogicalType TPoseTypes::TPOSE() { + auto type = LogicalType(LogicalTypeId::BLOB); + type.SetAlias("TPOSE"); + return type; +} + +/* + * Constructors +*/ + +inline void Tpose_constructor(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> string_t { + std::string input = input_geom_str.GetString(); + + Temporal *tinst = tpose_in(input.c_str()); + if (!tinst) { + throw InvalidInputException("Invalid TPOSE input: " + input); + } + + size_t data_size = temporal_mem_size(tinst); + + uint8_t *data_buffer = (uint8_t*)malloc(data_size); + if (!data_buffer) { + free(tinst); + throw InvalidInputException("Failed to allocate memory for TPOSE data"); + } + + memcpy(data_buffer, tinst, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer), data_size); + string_t stored_data = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(tinst); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Tposeinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &value_vec = args.data[0]; + auto &t_vec = args.data[1]; + + BinaryExecutor::Execute( + value_vec, t_vec, result, count, + [&](string_t value_str, timestamp_tz_t t) -> string_t { + std::string value = value_str.GetString(); + + // The tpose value type is a Pose (position + orientation): + // a 2D pose is a point plus a rotation angle, a 3D pose a + // point plus an orientation quaternion. It is parsed from + // its canonical text form, e.g. 'Pose(Point(1 1), 0.5)'. + Pose *po = pose_in(value.c_str()); + + if (po == NULL) { + throw InvalidInputException("Invalid pose format: " + value); + } + + timestamp_tz_t meos_timestamp = DuckDBToMeosTimestamp(t); + // No tposeinst_make exists; the generic tinstant_make + // builds a T_TPOSE instant from the Pose Datum. + TInstant *inst = tinstant_make(Datum(po), T_TPOSE, + static_cast(meos_timestamp.value)); + + if (inst == NULL) { + free(po); + throw InvalidInputException("Failed to create TInstant"); + } + + size_t data_size = temporal_mem_size((Temporal*)inst); + + uint8_t *data_buffer = (uint8_t *)malloc(data_size); + + if (!data_buffer){ + free(inst); + free(po); + throw InvalidInputException("Failed to allocate memory to pose data"); + } + memcpy(data_buffer, inst, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer),data_size); + string_t stored_data = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(inst); + free(po); + + return stored_data; + + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Tpose_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { + const char* default_interp = "linear"; + auto count = args.size(); + auto arg_count = args.ColumnCount(); + + auto &input_geom_vec = args.data[0]; + auto &span_vec = args.data[1]; + + // Check if interpolation parameter is provided + Vector *interp_vec = nullptr; + if (arg_count > 2) { + interp_vec = &args.data[2]; + } + + BinaryExecutor::Execute( + input_geom_vec, span_vec, result, count, + [&](string_t input_geom_str, string_t span_str)-> string_t{ + std::string geom_value = input_geom_str.GetString(); + + Pose *po = pose_in(geom_value.c_str()); + + if(po == NULL){ + throw InvalidInputException("Invalid pose format: "+ geom_value); + } + + std::string input = span_str.GetString(); + + Span *span_cmp = reinterpret_cast(const_cast(input.c_str())); + + // Use default interpolation or provided value + interpType interp = interptype_from_string(default_interp); + if (interp_vec) { + std::string interp_string = default_interp; + interp = interptype_from_string(interp_string.c_str()); + } + + TSequence *seq = tsequence_from_base_tstzspan(Datum(po), T_TPOSE, span_cmp, interp); + + if (seq == NULL) { + free(po); + throw InvalidInputException("Failed to create TSequence"); + } + + size_t seq_size = temporal_mem_size((Temporal*)seq); + + uint8_t *seq_buffer = (uint8_t *)malloc(seq_size); + if (!seq_buffer) { + free(seq); + free(po); + throw InvalidInputException("Failed to allocate memory for sequence data"); + } + + memcpy(seq_buffer, seq, seq_size); + + string_t seq_string_t((char*) seq_buffer, seq_size); + string_t stored_data = StringVector::AddStringOrBlob(result, seq_string_t); + + free(seq_buffer); + free(seq); + free(po); + + return stored_data; + + }); + + if (count == 1){ + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +TInstant **temparr_extract_ps(Vector &tpose_arr_vec, list_entry_t list_entry, int *count) { + auto &child_vector = ListVector::GetEntry(tpose_arr_vec); + auto list_size = list_entry.length; + auto list_offset = list_entry.offset; + + if (list_size == 0) { + *count = 0; + return nullptr; + } + + *count = list_size; + + TInstant **instants = (TInstant**)malloc(sizeof(TInstant*) * list_size); + if (!instants) { + *count = 0; + return nullptr; + } + + for (idx_t i = 0; i < list_size; i++) { + auto element_idx = list_offset + i; + string_t tgeom_blob = FlatVector::GetData(child_vector)[element_idx]; + + const uint8_t *data = reinterpret_cast(tgeom_blob.GetData()); + size_t data_size = tgeom_blob.GetSize(); + + if (data_size < sizeof(void*)) { + for (idx_t j = 0; j < i; j++) { + if (instants[j]) free(instants[j]); + } + free(instants); + *count = 0; + return nullptr; + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + for (idx_t j = 0; j < i; j++) { + if (instants[j]) free(instants[j]); + } + free(instants); + *count = 0; + return nullptr; + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + if (!temp) { + free(data_copy); + for (idx_t j = 0; j < i; j++) { + if (instants[j]) free(instants[j]); + } + free(instants); + *count = 0; + return nullptr; + } + + instants[i] = (TInstant*)temp; + } + + return instants; +} + +inline void Tpose_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { + // Default values + const char* default_interp = "linear"; + bool default_lower_inc = true; + bool default_upper_inc = true; + + auto count = args.size(); + auto arg_count = args.ColumnCount(); + + + auto &tpose_arr_vec = args.data[0]; + tpose_arr_vec.Flatten(count); + + Vector *interp_vec = nullptr; + Vector *lower_vec = nullptr; + Vector *upper_vec = nullptr; + + if (arg_count > 1) { + interp_vec = &args.data[1]; + interp_vec->Flatten(count); + } + if (arg_count > 2) { + lower_vec = &args.data[2]; + lower_vec->Flatten(count); + } + if (arg_count > 3) { + upper_vec = &args.data[3]; + upper_vec->Flatten(count); + } + + result.Flatten(count); + + auto tpose_data = FlatVector::GetData(tpose_arr_vec); + auto result_data = FlatVector::GetData(result); + + // Get validity masks + auto &tpose_validity = FlatVector::Validity(tpose_arr_vec); + auto &result_validity = FlatVector::Validity(result); + + for (idx_t i = 0; i < count; i++) { + if (!tpose_validity.RowIsValid(i)) { + result_validity.SetInvalid(i); + continue; + } + + try { + list_entry_t list_entry = tpose_data[i]; + + // Handle interp parameter with default + std::string interp_str = default_interp; + if (interp_vec) { + auto interp_data = FlatVector::GetData(*interp_vec); + auto &interp_validity = FlatVector::Validity(*interp_vec); + if (interp_validity.RowIsValid(i)) { + interp_str = interp_data[i].GetString(); + } + } + interpType interp = interptype_from_string(interp_str.c_str()); + + bool lower_inc = default_lower_inc; + bool upper_inc = default_upper_inc; + + if (lower_vec) { + auto lower_data = FlatVector::GetData(*lower_vec); + auto &lower_validity = FlatVector::Validity(*lower_vec); + if (lower_validity.RowIsValid(i)) { + lower_inc = lower_data[i]; + } + } + + if (upper_vec) { + auto upper_data = FlatVector::GetData(*upper_vec); + auto &upper_validity = FlatVector::Validity(*upper_vec); + if (upper_validity.RowIsValid(i)) { + upper_inc = upper_data[i]; + } + } + + // Extract array elements + int element_count; + TInstant **instants = temparr_extract_ps(tpose_arr_vec, list_entry, &element_count); + + if (!instants || element_count == 0) { + result_validity.SetInvalid(i); + continue; + } + + TSequence *sequence_result = tsequence_make((TInstant **) instants, element_count, + lower_inc, upper_inc, interp, true); + + if (!sequence_result) { + for (int j = 0; j < element_count; j++) { + if (instants[j]) { + free(instants[j]); + } + } + free(instants); + result_validity.SetInvalid(i); + continue; + } + + size_t data_size = temporal_mem_size(reinterpret_cast(sequence_result)); + uint8_t *data_buffer = (uint8_t*)malloc(data_size); + if (!data_buffer) { + free(sequence_result); + for (int j = 0; j < element_count; j++) { + if (instants[j]) { + free(instants[j]); + } + } + free(instants); + result_validity.SetInvalid(i); + continue; + } + + memcpy(data_buffer, sequence_result, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer), data_size); + result_data[i] = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(sequence_result); + for (int j = 0; j < element_count; j++) { + if (instants[j]) { + free(instants[j]); + } + } + free(instants); + + } catch (const std::exception& e) { + result_validity.SetInvalid(i); + } + } + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + + +/* + * Conversions +*/ + +inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + if (!temp) { + throw InvalidInputException("Invalid TPOSE data: null pointer"); + } + + Span *timespan = temporal_to_tstzspan(temp); + + if (!timespan) { + throw InvalidInputException("Failed to extract timespan from TPOSE"); + } + + size_t span_size = sizeof(Span); + + uint8_t *span_buffer = (uint8_t*)malloc(span_size); + if (!span_buffer) { + free(timespan); + throw InvalidInputException("Failed to allocate memory for timespan data"); + } + + memcpy(span_buffer, timespan, span_size); + + string_t span_string_t(reinterpret_cast(span_buffer), span_size); + string_t stored_data = StringVector::AddStringOrBlob(result, span_string_t); + + free(span_buffer); + free(timespan); + + return stored_data; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +/* + * Transformations +*/ + +inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + if (!temp) { + throw InvalidInputException("Invalid TPOSE data: null pointer"); + } + + TInstant *inst = temporal_to_tinstant(temp); + if (!inst) { + throw InvalidInputException("Failed to convert TPOSE to TInstant"); + } + + size_t inst_size = temporal_mem_size((Temporal*)inst); + + uint8_t *inst_buffer = (uint8_t*)malloc(inst_size); + if (!inst_buffer) { + free(inst); + throw InvalidInputException("Failed to allocate memory for TInstant data"); + } + + memcpy(inst_buffer, inst, inst_size); + + string_t inst_string_t(reinterpret_cast(inst_buffer), inst_size); + string_t stored_data = StringVector::AddStringOrBlob(result, inst_string_t); + + free(inst_buffer); + free(inst); + + return stored_data; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + auto &interp_vec = args.data[1]; + + tgeom_vec.Flatten(count); + interp_vec.Flatten(count); + + BinaryExecutor::Execute( + tgeom_vec, interp_vec, result, count, + [&](string_t tgeom_str_t, string_t interp_str_t) -> string_t { + + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TPOSE data: null pointer"); + } + + std::string interp_str = interp_str_t.GetString(); + interpType new_interp = interptype_from_string(interp_str.c_str()); + + Temporal *result_temp = temporal_set_interp(temp, new_interp); + if (!result_temp) { + throw InvalidInputException("Failed to set interpolation"); + } + + // Serialize result back to binary + size_t result_size = temporal_mem_size(result_temp); + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(result_temp); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, result_temp, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_data = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(result_temp); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom1_vec = args.data[0]; + auto &tgeom2_vec = args.data[1]; + + tgeom1_vec.Flatten(count); + tgeom2_vec.Flatten(count); + + BinaryExecutor::Execute( + tgeom1_vec, tgeom2_vec, result, count, + [&](string_t tgeom1_str_t, string_t tgeom2_str_t) -> string_t { + std::string tgeom1 = tgeom1_str_t.GetString(); + + Temporal *temp1 = reinterpret_cast(const_cast(tgeom1.c_str())); + if (!temp1) { + throw InvalidInputException("Invalid TPOSE data: null pointer"); + } + + std::string tgeom2 = tgeom2_str_t.GetString(); + + Temporal *temp2 = reinterpret_cast(const_cast(tgeom2.c_str())); + if (!temp2) { + throw InvalidInputException("Invalid TPOSE data: null pointer"); + } + + Temporal *result_temp = temporal_merge(temp1, temp2); + if (!result_temp) { + throw InvalidInputException("Failed to merge temporal poses"); + } + + // Serialize result back to binary + size_t result_size = temporal_mem_size(result_temp); + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(result_temp); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, result_temp, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_data = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(result_temp); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +/* + * Accessor Functions +*/ + +inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + + tgeom_vec.Flatten(count); + + UnaryExecutor::Execute( + tgeom_vec, result, count, + [&](string_t tgeom_str_t) -> string_t { + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TPOSE data: null pointer"); + } + + const char *subtype_str = temporal_subtype(temp); + if (!subtype_str) { + throw InvalidInputException("Failed to get temporal subtype"); + } + + std::string result_str(subtype_str); + string_t stored_result = StringVector::AddString(result, result_str); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + + +inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + + tgeom_vec.Flatten(count); + + UnaryExecutor::Execute( + tgeom_vec, result, count, + [&](string_t tgeom_str_t) -> string_t { + + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TPOSE data: null pointer"); + } + + + const char *interp_str = temporal_interp(temp); + if (!interp_str) { + throw InvalidInputException("Failed to get temporal interpolation"); + } + + std::string result_str(interp_str); + string_t stored_result = StringVector::AddString(result, result_str); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + + tgeom_vec.Flatten(count); + + UnaryExecutor::Execute( + tgeom_vec, result, count, + [&](string_t tgeom_str_t) -> int32_t { + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TPOSE data: null pointer"); + } + + size_t mem_size = temporal_mem_size(temp); + + + return static_cast(mem_size); + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +// ---- Pose value accessors ---- +// The tpose value type is a Pose (position + orientation), which is not +// a registered DuckDB type: a 2D pose is a point plus a rotation angle, +// a 3D pose a point plus an orientation quaternion. getValue / +// startValue / endValue surface it in its canonical text form +// (`Pose(POINT(x y),theta)`), mirroring the asText output. point(tpose) +// returns the position geometry via pose_to_point and rotation(tpose) +// returns the 2D rotation angle via pose_rotation, per the manual model. + +inline Pose *pose_from_instant_value(const TInstant *inst) { + Datum d = tinstant_value(inst); + return reinterpret_cast(d); +} + +inline void Tpose_get_value(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + TInstant *tinst = reinterpret_cast(const_cast(input.c_str())); + + // tinstant_value returns a freshly allocated copy of the + // Pose value (datum_copy), which the caller owns. + Pose *po = pose_from_instant_value(tinst); + + char *str = pose_as_text(po, 15); + if (!str) { + free(po); + throw InvalidInputException("Failed to convert pose value to text"); + } + std::string output(str); + string_t stored_result = StringVector::AddString(result, output); + + free(str); + free(po); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + +inline void Tpose_start_value(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + // temporal_start_value returns a freshly allocated copy of + // the Pose value (datum_copy), which the caller owns. + Datum start_datum = temporal_start_value(temp); + + Pose *po = reinterpret_cast(start_datum); + char *str = pose_as_text(po, 15); + if (!str) { + free(po); + throw InvalidInputException("Failed to convert pose value to text"); + } + std::string output(str); + string_t stored_result = StringVector::AddString(result, output); + + free(str); + free(po); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Tpose_end_value(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + // temporal_end_value returns a freshly allocated copy of + // the Pose value (datum_copy), which the caller owns. + Datum end_datum = temporal_end_value(temp); + + Pose *po = reinterpret_cast(end_datum); + char *str = pose_as_text(po, 15); + if (!str) { + free(po); + throw InvalidInputException("Failed to convert pose value to text"); + } + std::string output(str); + string_t stored_result = StringVector::AddString(result, output); + + free(str); + free(po); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Tpose_point(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + // temporal_start_value returns a freshly allocated copy of + // the Pose value (datum_copy), which the caller owns. + Datum start_datum = temporal_start_value(temp); + Pose *po = reinterpret_cast(start_datum); + + // pose_to_point returns a freshly allocated GSERIALIZED copy + // of the pose's position geometry. + GSERIALIZED *gs = pose_to_point(po); + if (!gs) { + free(po); + throw InvalidInputException("Failed to extract point from pose"); + } + + string_t geometry_blob = GSerializedToGeometry(gs, state, result); + string_t stored_result = StringVector::AddStringOrBlob(result, geometry_blob); + + free(gs); + free(po); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Tpose_rotation(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> double { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + // temporal_start_value returns a freshly allocated copy of + // the Pose value (datum_copy), which the caller owns. + Datum start_datum = temporal_start_value(temp); + Pose *po = reinterpret_cast(start_datum); + + // pose_rotation returns the 2D rotation angle (theta). + double theta = pose_rotation(po); + free(po); + return theta; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal* temp = reinterpret_cast(const_cast(input.c_str())); + + bool lower_inc = temporal_lower_inc(temp); + + std::string result_str = lower_inc ? "true" : "false"; + string_t stored_result = StringVector::AddString(result, result_str); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal* temp = reinterpret_cast(const_cast(input.c_str())); + + bool upper_inc = temporal_upper_inc(temp); + + std::string result_str = upper_inc ? "true" : "false"; + string_t stored_result = StringVector::AddString(result, result_str); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + TInstant *start_inst = temporal_start_instant(temp); + + if (!start_inst) { + throw InvalidInputException("Failed to get start_inst from temporal object"); + } + + size_t result_size = temporal_mem_size((Temporal*)start_inst); + if (result_size == 0) { + throw InvalidInputException("Invalid result size from temporal object"); + } + + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(start_inst); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, start_inst, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_result = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(start_inst); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + TInstant *end_inst = temporal_end_instant(temp); + + if (!end_inst) { + throw InvalidInputException("Failed to get end_inst from temporal object"); + } + + size_t result_size = temporal_mem_size((Temporal*)end_inst); + if (result_size == 0) { + throw InvalidInputException("Invalid result size from temporal object"); + } + + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(end_inst); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, end_inst, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_result = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(end_inst); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + + +inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + auto &n_vec = args.data[1]; + + BinaryExecutor::Execute( + tgeom_vec, n_vec, result, count, + [&](string_t tgeom_str, int32_t n) -> string_t { + std::string tgeom = tgeom_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(tgeom.c_str())); + + TInstant *inst_n = temporal_instant_n(temp, n); + if (!inst_n) { + throw InvalidInputException("Failed to get instant n from temporal object"); + } + + size_t result_size = temporal_mem_size((Temporal*)inst_n); + if (result_size == 0) { + throw InvalidInputException("Invalid result size from temporal object"); + } + + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(inst_n); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, inst_n, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_result = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(inst_n); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> timestamp_tz_t { + const uint8_t *data = reinterpret_cast(input_geom_str.GetData()); + size_t data_size = input_geom_str.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TPOSE data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TPOSE deserialization"); + } + memcpy(data_copy, data, data_size); + + TInstant *temp = reinterpret_cast(data_copy); + + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TPOSE data: null pointer"); + } + + TimestampTz meos_t = temp->t; + + timestamp_tz_t meos_timestamp{meos_t}; + timestamp_tz_t duckdb_t = MeosToDuckDBTimestamp(meos_timestamp); + + free(data_copy); + + return duckdb_t; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +void TPoseTypes::RegisterScalarFunctions(ExtensionLoader &loader) { + + auto tpose_function = ScalarFunction( + "TPOSE", + {LogicalType::VARCHAR}, + TPoseTypes::TPOSE(), + Tpose_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tpose_function); + + auto tpose_from_timestamp_function = ScalarFunction( + "TPOSE", + {LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ}, + TPoseTypes::TPOSE(), + Tposeinst_constructor); + duckdb::RegisterSerializedScalarFunction(loader, tpose_from_timestamp_function); + + auto tpose_from_tstzspan_function = ScalarFunction( + "TPOSE", + {LogicalType::VARCHAR, SpanTypes::TSTZSPAN(), LogicalType::VARCHAR}, + TPoseTypes::TPOSE(), + Tpose_sequence_from_tstzspan + ); + duckdb::RegisterSerializedScalarFunction(loader, tpose_from_tstzspan_function); + + auto tpose_from_tstzspan_default = ScalarFunction( + "TPOSE", + {LogicalType::VARCHAR, SpanTypes::TSTZSPAN()}, + TPoseTypes::TPOSE(), + Tpose_sequence_from_tstzspan + ); + duckdb::RegisterSerializedScalarFunction(loader, tpose_from_tstzspan_default); + + auto tposeseqarr_1param= ScalarFunction( + "tposeSeq", + {LogicalType::LIST(TPoseTypes::TPOSE())}, + TPoseTypes::TPOSE(), + Tpose_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tposeseqarr_1param); + + auto tposeseqarr_2params = ScalarFunction( + "tposeSeq", + {LogicalType::LIST(TPoseTypes::TPOSE()), LogicalType::VARCHAR}, + TPoseTypes::TPOSE(), + Tpose_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tposeseqarr_2params); + + auto tposeseqarr_3params = ScalarFunction( + "tposeSeq", + {LogicalType::LIST(TPoseTypes::TPOSE()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, + TPoseTypes::TPOSE(), + Tpose_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tposeseqarr_3params); + + auto tposeseqarr_4params = ScalarFunction( + "tposeSeq", + {LogicalType::LIST(TPoseTypes::TPOSE()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, + TPoseTypes::TPOSE(), + Tpose_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, tposeseqarr_4params); + + auto tpose_to_timespan_function = ScalarFunction( + "timeSpan", + {TPoseTypes::TPOSE()}, + SpanTypes::TSTZSPAN(), + Temporal_to_tstzspan); + duckdb::RegisterSerializedScalarFunction(loader, tpose_to_timespan_function); + + auto tpose_to_tinstant_function = ScalarFunction( + "tposeInst", + {TPoseTypes::TPOSE()}, + TPoseTypes::TPOSE(), + Temporal_to_tinstant); + duckdb::RegisterSerializedScalarFunction(loader, tpose_to_tinstant_function); + + + auto setInterp_function = ScalarFunction( + "setInterp", + {TPoseTypes::TPOSE(), LogicalType::VARCHAR}, + TPoseTypes::TPOSE(), + Temporal_set_interp + ); + duckdb::RegisterSerializedScalarFunction(loader, setInterp_function); + + + auto merge_function = ScalarFunction( + "merge", + {TPoseTypes::TPOSE(), TPoseTypes::TPOSE()}, + TPoseTypes::TPOSE(), + Temporal_merge + ); + duckdb::RegisterSerializedScalarFunction(loader, merge_function); + + auto tempSubtype_function = ScalarFunction( + "tempSubtype", + {TPoseTypes::TPOSE()}, + LogicalType::VARCHAR, + Temporal_subtype + ); + duckdb::RegisterSerializedScalarFunction(loader, tempSubtype_function); + + auto interp_function = ScalarFunction( + "interp", + {TPoseTypes::TPOSE()}, + LogicalType::VARCHAR, + Temporal_interp + ); + duckdb::RegisterSerializedScalarFunction(loader, interp_function); + + auto memSize_function = ScalarFunction( + "memSize", + {TPoseTypes::TPOSE()}, + LogicalType::INTEGER, + Temporal_mem_size + ); + duckdb::RegisterSerializedScalarFunction(loader, memSize_function); + + auto getValue_function = ScalarFunction( + "getValue", + {TPoseTypes::TPOSE()}, + LogicalType::VARCHAR, + Tpose_get_value + ); + duckdb::RegisterSerializedScalarFunction(loader, getValue_function); + + + auto tpose_start_value_function = ScalarFunction( + "startValue", + {TPoseTypes::TPOSE()}, + LogicalType::VARCHAR, + Tpose_start_value + ); + duckdb::RegisterSerializedScalarFunction(loader, tpose_start_value_function); + + auto tpose_end_value_function = ScalarFunction( + "endValue", + {TPoseTypes::TPOSE()}, + LogicalType::VARCHAR, + Tpose_end_value + ); + duckdb::RegisterSerializedScalarFunction(loader, tpose_end_value_function); + + auto tpose_point_function = ScalarFunction( + "point", + {TPoseTypes::TPOSE()}, + GeoTypes::GEOMETRY(), + Tpose_point + ); + duckdb::RegisterSerializedScalarFunction(loader, tpose_point_function); + + auto tpose_rotation_function = ScalarFunction( + "rotation", + {TPoseTypes::TPOSE()}, + LogicalType::DOUBLE, + Tpose_rotation + ); + duckdb::RegisterSerializedScalarFunction(loader, tpose_rotation_function); + + auto startInstant_function = ScalarFunction( + "startInstant", + {TPoseTypes::TPOSE()}, + TPoseTypes::TPOSE(), + Temporal_start_instant + ); + duckdb::RegisterSerializedScalarFunction(loader, startInstant_function); + + auto endInstant_function = ScalarFunction( + "endInstant", + {TPoseTypes::TPOSE()}, + TPoseTypes::TPOSE(), + Temporal_end_instant + ); + duckdb::RegisterSerializedScalarFunction(loader, endInstant_function); + + auto instantN_function = ScalarFunction( + "instantN", + {TPoseTypes::TPOSE(), LogicalType::INTEGER}, + TPoseTypes::TPOSE(), + Temporal_instant_n + ); + duckdb::RegisterSerializedScalarFunction(loader, instantN_function); + + + auto tpose_gettimestamptz_function = ScalarFunction( + "getTimestamp", + {TPoseTypes::TPOSE()}, + LogicalType::TIMESTAMP_TZ, + Tinstant_timestamptz); + duckdb::RegisterSerializedScalarFunction(loader, tpose_gettimestamptz_function); + + + // =================================================================== + // Foundational tpose surface — accessors, time/value-restrict, + // modifiers, and comparison. The MEOS C functions delegated to here + // are subtype-agnostic (they take Temporal *), so we reuse the same + // generic handlers wired for tgeompoint in temporal_functions.cpp. + // =================================================================== + + const LogicalType TGEOM = TPoseTypes::TPOSE(); + const LogicalType TSTZ = LogicalType::TIMESTAMP_TZ; + const LogicalType IVAL = LogicalType::INTERVAL; + + // ---- Accessors ---- + loader.RegisterFunction(ScalarFunction( + "valueAtTimestamp", {TGEOM, TSTZ}, LogicalType::VARCHAR, + Tpose_get_value)); + loader.RegisterFunction(ScalarFunction( + "getTime", {TGEOM}, SpansetTypes::tstzspanset(), + TemporalFunctions::Temporal_time)); + loader.RegisterFunction(ScalarFunction( + "duration", {TGEOM}, IVAL, + TemporalFunctions::Temporal_duration)); + loader.RegisterFunction(ScalarFunction( + "duration", {TGEOM, LogicalType::BOOLEAN}, IVAL, + TemporalFunctions::Temporal_duration)); + loader.RegisterFunction(ScalarFunction( + "lowerInc", {TGEOM}, LogicalType::BOOLEAN, + TemporalFunctions::Temporal_lower_inc)); + loader.RegisterFunction(ScalarFunction( + "upperInc", {TGEOM}, LogicalType::BOOLEAN, + TemporalFunctions::Temporal_upper_inc)); + loader.RegisterFunction(ScalarFunction( + "numInstants", {TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_num_instants)); + loader.RegisterFunction(ScalarFunction( + "instants", {TGEOM}, LogicalType::LIST(TGEOM), + TemporalFunctions::Temporal_instants)); + loader.RegisterFunction(ScalarFunction( + "numSequences", {TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_num_sequences)); + loader.RegisterFunction(ScalarFunction( + "sequences", {TGEOM}, LogicalType::LIST(TGEOM), + TemporalFunctions::Temporal_sequences)); + loader.RegisterFunction(ScalarFunction( + "startSequence", {TGEOM}, TGEOM, + TemporalFunctions::Temporal_start_sequence)); + loader.RegisterFunction(ScalarFunction( + "endSequence", {TGEOM}, TGEOM, + TemporalFunctions::Temporal_end_sequence)); + loader.RegisterFunction(ScalarFunction( + "sequenceN", {TGEOM, LogicalType::INTEGER}, TGEOM, + TemporalFunctions::Temporal_sequence_n)); + loader.RegisterFunction(ScalarFunction( + "numTimestamps", {TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_num_timestamps)); + loader.RegisterFunction(ScalarFunction( + "timestamps", {TGEOM}, LogicalType::LIST(TSTZ), + TemporalFunctions::Temporal_timestamps)); + loader.RegisterFunction(ScalarFunction( + "startTimestamp", {TGEOM}, TSTZ, + TemporalFunctions::Temporal_start_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "endTimestamp", {TGEOM}, TSTZ, + TemporalFunctions::Temporal_end_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "timestampN", {TGEOM, LogicalType::INTEGER}, TSTZ, + TemporalFunctions::Temporal_timestamptz_n)); + loader.RegisterFunction(ScalarFunction( + "segments", {TGEOM}, LogicalType::LIST(TGEOM), + TemporalFunctions::Temporal_segments)); + + // ---- Time-domain restrict / minus ---- + for (const auto &t : std::vector>{ + {TSTZ, TemporalFunctions::Temporal_at_timestamptz}, + {SetTypes::tstzset(), TemporalFunctions::Temporal_at_tstzset}, + {SpanTypes::TSTZSPAN(), TemporalFunctions::Temporal_at_tstzspan}, + {SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_at_tstzspanset}}) { + loader.RegisterFunction(ScalarFunction( + "atTime", {TGEOM, t.first}, TGEOM, t.second)); + } + for (const auto &t : std::vector>{ + {TSTZ, TemporalFunctions::Temporal_minus_timestamptz}, + {SetTypes::tstzset(), TemporalFunctions::Temporal_minus_tstzset}, + {SpanTypes::TSTZSPAN(), TemporalFunctions::Temporal_minus_tstzspan}, + {SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_minus_tstzspanset}}) { + loader.RegisterFunction(ScalarFunction( + "minusTime", {TGEOM, t.first}, TGEOM, t.second)); + } + + // beforeTimestamp / afterTimestamp accept timestamptz + loader.RegisterFunction(ScalarFunction( + "beforeTimestamp", {TGEOM, TSTZ}, TGEOM, + TemporalFunctions::Temporal_before_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "afterTimestamp", {TGEOM, TSTZ}, TGEOM, + TemporalFunctions::Temporal_after_timestamptz)); + + // ---- Modifiers (shift / scale / shiftScale / append / insert / update / + // delete) ---- + loader.RegisterFunction(ScalarFunction( + "shiftTime", {TGEOM, IVAL}, TGEOM, + TemporalFunctions::Temporal_shift_time)); + loader.RegisterFunction(ScalarFunction( + "scaleTime", {TGEOM, IVAL}, TGEOM, + TemporalFunctions::Temporal_scale_time)); + loader.RegisterFunction(ScalarFunction( + "shiftScaleTime", {TGEOM, IVAL, IVAL}, TGEOM, + TemporalFunctions::Temporal_shift_scale_time)); + loader.RegisterFunction(ScalarFunction( + "appendInstant", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_append_tinstant)); + loader.RegisterFunction(ScalarFunction( + "appendSequence", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_append_tsequence)); + loader.RegisterFunction(ScalarFunction( + "insert", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_insert)); + loader.RegisterFunction(ScalarFunction( + "insert", {TGEOM, TGEOM, LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_insert)); + loader.RegisterFunction(ScalarFunction( + "update", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_update)); + loader.RegisterFunction(ScalarFunction( + "update", {TGEOM, TGEOM, LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_update)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, TSTZ}, TGEOM, + TemporalFunctions::Temporal_delete_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, TSTZ, LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SetTypes::tstzset()}, TGEOM, + TemporalFunctions::Temporal_delete_tstzset)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SetTypes::tstzset(), LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_tstzset)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpanTypes::TSTZSPAN()}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspan)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpanTypes::TSTZSPAN(), LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspan)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpansetTypes::tstzspanset()}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspanset)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpansetTypes::tstzspanset(), LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspanset)); + + // ---- Comparison (named functions + operators) ---- + struct CmpEntry { + const char *name; + scalar_function_t fn; + }; + const std::vector named_cmps = { + {"temporal_eq", TemporalFunctions::Temporal_eq}, + {"temporal_ne", TemporalFunctions::Temporal_ne}, + {"temporal_lt", TemporalFunctions::Temporal_lt}, + {"temporal_le", TemporalFunctions::Temporal_le}, + {"temporal_gt", TemporalFunctions::Temporal_gt}, + {"temporal_ge", TemporalFunctions::Temporal_ge}, + }; + for (const auto &c : named_cmps) { + loader.RegisterFunction(ScalarFunction( + c.name, {TGEOM, TGEOM}, LogicalType::BOOLEAN, c.fn)); + } + loader.RegisterFunction(ScalarFunction( + "temporal_cmp", {TGEOM, TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_cmp)); + + // Operator forms — mirror the registrations tgeometry.cpp does. + const std::vector op_cmps = { + {"=", TemporalFunctions::Temporal_eq}, + {"<>", TemporalFunctions::Temporal_ne}, + {"<", TemporalFunctions::Temporal_lt}, + {"<=", TemporalFunctions::Temporal_le}, + {">", TemporalFunctions::Temporal_gt}, + {">=", TemporalFunctions::Temporal_ge}, + }; + for (const auto &c : op_cmps) { + loader.RegisterFunction(ScalarFunction( + c.name, {TGEOM, TGEOM}, LogicalType::BOOLEAN, c.fn)); + } +} + +void TPoseTypes::RegisterTypes(ExtensionLoader &loader) { + loader.RegisterType( "TPOSE", TPoseTypes::TPOSE()); +} + + +} diff --git a/src/geo/tpose_in_out.cpp b/src/geo/tpose_in_out.cpp new file mode 100644 index 00000000..05d5e754 --- /dev/null +++ b/src/geo/tpose_in_out.cpp @@ -0,0 +1,432 @@ +#include "geo/tpose.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include "duckdb/common/extension_type_info.hpp" +#include +#include +#include +#include "mobilityduck/meos_exec_serial.hpp" + +extern "C" { + #include + #include + #include + #include + #include +} + +namespace duckdb { + +inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> string_t { + const uint8_t *data = reinterpret_cast(input_geom_str.GetData()); + size_t data_size = input_geom_str.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TPOSE data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TPOSE deserialization"); + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TPOSE data: null pointer"); + } + + char *str = tspatial_as_text(temp, 0); + + if (!str) { + free(data_copy); + throw InvalidInputException("Failed to convert TPOSE to text"); + } + + std::string result_str(str); + string_t stored_result = StringVector::AddString(result, result_str); + + free(str); + free(data_copy); + + return stored_result; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> string_t { + + const uint8_t *data = reinterpret_cast(input_geom_str.GetData()); + size_t data_size = input_geom_str.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TPOSE data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TPOSE deserialization"); + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TPOSE data: null pointer"); + } + + char *ewkt = tspatial_as_ewkt(temp, 0); + + if (!ewkt) { + free(data_copy); + throw InvalidInputException("Failed to convert TPOSE to EWKT"); + } + + std::string result_str(ewkt); + string_t stored_result = StringVector::AddString(result, result_str); + + + free(ewkt); + free(data_copy); + + return stored_result; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +bool TposeFunctions::StringToTpose(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { + UnaryExecutor::Execute( + source, result, count, + [&](string_t input_string) -> string_t { + std::string input_str = input_string.GetString(); + + Temporal *temp = tpose_in(input_str.c_str()); + if (!temp) { + throw InvalidInputException("Invalid TPOSE input: " + input_str); + } + + size_t data_size = temporal_mem_size(temp); + uint8_t *data_buffer = (uint8_t*)malloc(data_size); + if (!data_buffer) { + free(temp); + throw InvalidInputException("Failed to allocate memory for TPOSE data"); + } + + memcpy(data_buffer, temp, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer), data_size); + string_t stored_data = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(temp); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } + return true; +} + +bool TposeFunctions::TposeToString(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { + UnaryExecutor::Execute( + source, result, count, + [&](string_t input_blob) -> string_t { + const uint8_t *data = reinterpret_cast(input_blob.GetData()); + size_t data_size = input_blob.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TPOSE data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TPOSE deserialization"); + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TPOSE data: null pointer"); + } + + char *str = temporal_out(temp, 15); + if (!str) { + free(data_copy); + throw InvalidInputException("Failed to convert TPOSE to string"); + } + + std::string output(str); + string_t stored_result = StringVector::AddString(result, output); + + free(str); + free(data_copy); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } + return true; +} + +// ---- Spatial-temporal parsers (Binary / HexWKB / MFJSON / Text) ---- +// Used to register the `tposeFrom*` overloads. +// `temporal_from_wkb` and `temporal_from_hexwkb` are subtype-agnostic; +// `tpose_in` is per-type. The temporal-pose MF-JSON support already +// lives on MobilityDB master (MovingPose typestring + dispatch), so no +// preceding MEOS parity PR is needed; MEOS does not, however, expose a +// header-declared `tpose_from_mfjson(const char *)` symbol (it is built +// under #if MEOS and is itself only a thin wrapper that calls +// `temporal_from_mfjson(mfjson, T_TPOSE)`). This port therefore routes +// through that subtype-agnostic dispatch directly, exactly as the +// canonical MobilityDB SQL binds `tposeFromMFJSON` to the generic +// Temporal_from_mfjson handler. The result is stored as a raw blob, +// the same format every other temporal type uses. + +inline string_t StoreTempAsBlob(Vector &result, Temporal *t) { + size_t sz = temporal_mem_size(t); + string_t stored = StringVector::AddStringOrBlob( + result, string_t(reinterpret_cast(t), sz)); + free(t); + return stored; +} + +inline void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + if (input.GetSize() == 0) + throw InvalidInputException("fromBinary: empty WKB input"); + uint8_t *wkb = (uint8_t *)malloc(input.GetSize()); + if (!wkb) throw InternalException("fromBinary: malloc failed"); + memcpy(wkb, input.GetData(), input.GetSize()); + Temporal *t = temporal_from_wkb(wkb, input.GetSize()); + free(wkb); + if (!t) throw InvalidInputException("fromBinary: invalid MEOS-WKB"); + return StoreTempAsBlob(result, t); + }); +} + +inline void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + std::string hex(input.GetData(), input.GetSize()); + Temporal *t = temporal_from_hexwkb(hex.c_str()); + if (!t) throw InvalidInputException( + "fromHexWKB: invalid hex-encoded MEOS-WKB"); + return StoreTempAsBlob(result, t); + }); +} + +inline void TposeFromTextExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + std::string s(input.GetData(), input.GetSize()); + Temporal *t = tpose_in(s.c_str()); + if (!t) throw InvalidInputException("from*: invalid input"); + return StoreTempAsBlob(result, t); + }); +} + +inline void TposeFromMFJSONExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + std::string s(input.GetData(), input.GetSize()); + // tpose exposes no header-declared *_from_mfjson symbol; + // route through the generic dispatch with the T_TPOSE + // temporal type, the same path the canonical MobilityDB SQL + // binds tposeFromMFJSON to. + Temporal *t = temporal_from_mfjson(s.c_str(), T_TPOSE); + if (!t) throw InvalidInputException("fromMFJSON: invalid input"); + return StoreTempAsBlob(result, t); + }); +} + +// asMFJSON(tpose[, with_bbox[, flags[, precision[, srs]]]]). MobilityDB +// exposes asMFJSON for every temporal type via the generic Temporal_as_mfjson; +// #151 shipped tposeFromMFJSON but not asMFJSON, so this closes that gap. +// Uniquely named (the ODR caveat): a generic name would collide with the +// asMFJSON execs in the other geo .cpp. Defaults match MobilityDB: +// with_bbox=false, flags=0, precision=15, srs=NULL. +void TposeAsMfjsonExec(DataChunk &args, ExpressionState &state, Vector &result) { + const idx_t row_count = args.size(); + for (idx_t i = 0; i < args.ColumnCount(); i++) args.data[i].Flatten(row_count); + auto in = FlatVector::GetData(args.data[0]); + auto out_data = FlatVector::GetData(result); + auto &out_validity = FlatVector::Validity(result); + const idx_t cc = args.ColumnCount(); + for (idx_t row = 0; row < row_count; row++) { + if (!FlatVector::Validity(args.data[0]).RowIsValid(row)) { + out_validity.SetInvalid(row); + continue; + } + string_t blob = in[row]; + uint8_t *copy = (uint8_t *)malloc(blob.GetSize()); + if (!copy) throw InternalException("asMFJSON: malloc failed"); + memcpy(copy, blob.GetData(), blob.GetSize()); + Temporal *t = reinterpret_cast(copy); + bool with_bbox = (cc > 1) ? FlatVector::GetData(args.data[1])[row] : false; + int flags = (cc > 2) ? FlatVector::GetData(args.data[2])[row] : 0; + int precision = (cc > 3) ? FlatVector::GetData(args.data[3])[row] : 15; + std::string srs; + const char *srs_cstr = nullptr; + if (cc > 4) { + string_t s = FlatVector::GetData(args.data[4])[row]; + srs.assign(s.GetData(), s.GetSize()); + srs_cstr = srs.empty() ? nullptr : srs.c_str(); + } + char *json = temporal_as_mfjson(t, with_bbox, flags, precision, srs_cstr); + free(copy); + if (!json) { out_validity.SetInvalid(row); continue; } + out_data[row] = StringVector::AddString(result, json); + free(json); + } + if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); +} + +// WKB output for tpose. #151 shipped the From{Binary,HexWKB,...} parsers but +// not the as{Binary,EWKB,HexWKB,HexEWKB} emitters; MobilityDB exposes both +// (via the generic temporal_as_wkb / temporal_as_hexwkb). Uniquely named per +// the ODR caveat. Static helper for the blob -> Temporal copy. +// WKB_BASE (no SRID) is a local constant; WKB_EXTENDED (0x04) is from meos_geo.h. +constexpr uint8_t WKB_BASE = 0x00; +static Temporal *TposeBlobToTemp(const string_t &blob) { + uint8_t *copy = (uint8_t *)malloc(blob.GetSize()); + if (!copy) throw InternalException("tpose blob->temporal: malloc failed"); + memcpy(copy, blob.GetData(), blob.GetSize()); + return reinterpret_cast(copy); +} + +void TposeAsWkbExec(DataChunk &args, ExpressionState &state, Vector &result, uint8_t variant) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + Temporal *t = TposeBlobToTemp(input); + size_t sz = 0; + uint8_t *wkb = temporal_as_wkb(t, variant, &sz); + free(t); + if (!wkb || sz == 0) { + if (wkb) free(wkb); + throw InternalException("temporal_as_wkb returned null"); + } + string_t blob(reinterpret_cast(wkb), sz); + string_t stored = StringVector::AddStringOrBlob(result, blob); + free(wkb); + return stored; + }); +} + +void TposeAsHexWkbExec(DataChunk &args, ExpressionState &state, Vector &result, uint8_t variant) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + Temporal *t = TposeBlobToTemp(input); + size_t sz = 0; + char *hex = temporal_as_hexwkb(t, variant, &sz); + (void) sz; + free(t); + if (!hex) throw InternalException("temporal_as_hexwkb returned null"); + string_t stored = StringVector::AddString(result, hex); + free(hex); + return stored; + }); +} + +void TPoseTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ + auto TposeAsText = ScalarFunction( + "asText", + {TPoseTypes::TPOSE()}, + LogicalType::VARCHAR, + Tspatial_as_text + ); + duckdb::RegisterSerializedScalarFunction(loader, TposeAsText); + + auto TposeAsEWKT = ScalarFunction( + "asEWKT", + {TPoseTypes::TPOSE()}, + LogicalType::VARCHAR, + Tspatial_as_ewkt + ); + duckdb::RegisterSerializedScalarFunction(loader, TposeAsEWKT); + + // ---- tposeFromBinary / FromEWKB (auto-detects format) ---- + const auto B = LogicalType::BLOB; + const auto V = LogicalType::VARCHAR; + const auto T = TPoseTypes::TPOSE(); + const auto BL = LogicalType::BOOLEAN; + const auto I = LogicalType::INTEGER; + + // asMFJSON(tpose[, with_bbox[, flags[, precision[, srs]]]]) + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("asMFJSON", {T}, V, TposeAsMfjsonExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("asMFJSON", {T, BL}, V, TposeAsMfjsonExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("asMFJSON", {T, BL, I}, V, TposeAsMfjsonExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("asMFJSON", {T, BL, I, I}, V, TposeAsMfjsonExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("asMFJSON", {T, BL, I, I, V}, V, TposeAsMfjsonExec)); + + // asBinary / asEWKB (base + extended WKB) and asHexWKB / asHexEWKB + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asBinary", {T}, B, + [](DataChunk &a, ExpressionState &s, Vector &r) { TposeAsWkbExec(a, s, r, WKB_BASE); })); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asEWKB", {T}, B, + [](DataChunk &a, ExpressionState &s, Vector &r) { TposeAsWkbExec(a, s, r, WKB_EXTENDED); })); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {T}, V, + [](DataChunk &a, ExpressionState &s, Vector &r) { TposeAsHexWkbExec(a, s, r, WKB_BASE); })); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asHexEWKB", {T}, V, + [](DataChunk &a, ExpressionState &s, Vector &r) { TposeAsHexWkbExec(a, s, r, WKB_EXTENDED); })); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tposeFromBinary", {B}, T, TspatialFromWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tposeFromEWKB", {B}, T, TspatialFromWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tposeFromHexWKB", {V}, T, TspatialFromHexWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tposeFromHexEWKB", {V}, T, TspatialFromHexWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tposeFromMFJSON", {V}, T, TposeFromMFJSONExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tposeFromText", {V}, T, TposeFromTextExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tposeFromEWKT", {V}, T, TposeFromTextExec)); +} + + +void TPoseTypes::RegisterCastFunctions(ExtensionLoader &loader) { + loader.RegisterCastFunction( LogicalType::VARCHAR, TPoseTypes::TPOSE(), TposeFunctions::StringToTpose); + loader.RegisterCastFunction( TPoseTypes::TPOSE(), LogicalType::VARCHAR, TposeFunctions::TposeToString); +} + +} diff --git a/src/include/geo/tpose.hpp b/src/include/geo/tpose.hpp new file mode 100644 index 00000000..3a297a19 --- /dev/null +++ b/src/include/geo/tpose.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include +#include "duckdb/common/exception.hpp" +#include "duckdb/common/string_util.hpp" +#include "duckdb/function/scalar_function.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include + +namespace duckdb { + + +struct TPoseTypes { + static LogicalType TPOSE(); + static LogicalType GEOMETRY(); + static void RegisterTypes(ExtensionLoader &loader); + static void RegisterScalarFunctions(ExtensionLoader &loader); + static void RegisterCastFunctions(ExtensionLoader &loader); + static void RegisterScalarInOutFunctions(ExtensionLoader &loader); +}; + +struct TposeFunctions { + static bool StringToTpose(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + static bool TposeToString(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + static bool WkbBlobToGeometry(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); +}; + + +} // namespace duckdb diff --git a/src/mobilityduck_extension.cpp b/src/mobilityduck_extension.cpp index d49971fe..b6720555 100644 --- a/src/mobilityduck_extension.cpp +++ b/src/mobilityduck_extension.cpp @@ -20,6 +20,9 @@ // the canonical ways1000.csv is embedded and materialized there on load. #include "ways_csv.inc" #endif +#if POSE +#include "geo/tpose.hpp" +#endif #include "geo/tgeometry.hpp" #include "geo/tgeometry_ops.hpp" #include "geo/tgeography.hpp" @@ -384,6 +387,14 @@ static void LoadInternal(ExtensionLoader &loader) { TNpointTypes::RegisterScalarInOutFunctions(loader); #endif + // Extended temporal type tpose (requires the MEOS POSE module). +#if POSE + TPoseTypes::RegisterScalarFunctions(loader); + TPoseTypes::RegisterTypes(loader); + TPoseTypes::RegisterCastFunctions(loader); + TPoseTypes::RegisterScalarInOutFunctions(loader); +#endif + SetTypes::RegisterTypes(loader); SetTypes::RegisterCastFunctions(loader); SetTypes::RegisterScalarFunctions(loader); diff --git a/test/sql/tpose.test b/test/sql/tpose.test new file mode 100644 index 00000000..96b2d5d4 --- /dev/null +++ b/test/sql/tpose.test @@ -0,0 +1,206 @@ +# name: test/sql/tpose.test +# description: Core tpose type port — construction, text/EWKT/MFJSON I/O +# and basic accessors. The tpose value is a Pose (a 2D point +# plus a rotation angle; 3D adds a quaternion). +# group: [sql] + +require mobilityduck + +# Test tpose constructor with parentheses +query I +SELECT asText(tpose('Pose(Point(1 1), 0.5)@2000-01-01')); +---- +Pose(POINT(1 1),0.5)@2000-01-01 00:00:00+01 + +# Test tpose constructor without parentheses +query I +SELECT asText(tpose 'Pose(Point(1 1), 0.5)@2000-01-01'); +---- +Pose(POINT(1 1),0.5)@2000-01-01 00:00:00+01 + +# Test asText with continuous sequence +query I +SELECT asText(tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02, Pose(Point(1 1), 0.5)@2000-01-03]'); +---- +[Pose(POINT(1 1),0.2)@2000-01-01 00:00:00+01, Pose(POINT(1 1),0.4)@2000-01-02 00:00:00+01, Pose(POINT(1 1),0.5)@2000-01-03 00:00:00+01] + +# Test asText with discrete sequence +query I +SELECT asText(tpose '{Pose(Point(1 1), 0.3)@2000-01-01, Pose(Point(1 1), 0.5)@2000-01-02}'); +---- +{Pose(POINT(1 1),0.3)@2000-01-01 00:00:00+01, Pose(POINT(1 1),0.5)@2000-01-02 00:00:00+01} + +# Test asEWKT is non-null +query I +SELECT asEWKT(tpose 'Pose(Point(1 1), 0.5)@2000-01-01') IS NOT NULL; +---- +true + +# Test value-and-timestamp constructor round-trips +query I +SELECT tpose('Pose(Point(1 1), 0.5)', timestamptz '2012-01-01 08:00:00') + = tpose 'Pose(Point(1 1), 0.5)@2012-01-01 08:00:00'; +---- +true + +# Test value-and-tstzspan constructor produces a 2-instant sequence +query I +SELECT numInstants(tpose('Pose(Point(1 1), 0.5)', tstzspan '[2001-01-01, 2001-01-02]')); +---- +2 + +# Test value-and-tstzspan constructor with linear interpolation +query I +SELECT interp(tpose('Pose(Point(1 1), 0.5)', tstzspan '[2001-01-01, 2001-01-02]', 'linear')); +---- +Linear + +# Test MFJSON input via the FromMFJSON constructor reconstructs the value +# (the canonical MEOS schema: typestring MovingPose, value object with a +# {lat,lon} position and a rotation for the 2D case). +query I +SELECT asText(tposeFromMFJSON('{"type":"MovingPose","values":[{"position":{"lat":1,"lon":1},"rotation":0.5}],"datetimes":["2000-01-01T00:00:00+01"],"interpolation":"None"}')) + = asText(tpose 'Pose(Point(1 1), 0.5)@2000-01-01'); +---- +true + +# Test asMFJSON / FromMFJSON round-trip is identity (format-agnostic) +query I +SELECT asText(tposeFromMFJSON(asMFJSON(tpose 'Pose(Point(1 1), 0.5)@2000-01-01'))) + = asText(tpose 'Pose(Point(1 1), 0.5)@2000-01-01'); +---- +true + +# Test MFJSON round-trip for a continuous sequence +query I +SELECT asText(tposeFromMFJSON(asMFJSON( + tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02, Pose(Point(1 1), 0.5)@2000-01-03]'))) + = asText(tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02, Pose(Point(1 1), 0.5)@2000-01-03]'); +---- +true + +# Test tposeFromText constructor +query I +SELECT asText(tposeFromText('Pose(Point(1 1), 0.5)@2000-01-01')) IS NOT NULL; +---- +true + +# Test binary round-trip is identity +query I +SELECT asText(tposeFromBinary(asBinary(tpose 'Pose(Point(1 1), 0.5)@2000-01-01'))) + = asText(tpose 'Pose(Point(1 1), 0.5)@2000-01-01'); +---- +true + +# Test timeSpan function +query I +SELECT timeSpan(tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-03]'); +---- +[2000-01-01 00:00:00+01, 2000-01-03 00:00:00+01] + +# Test setInterp with discrete interpolation. A multi-instant continuous +# sequence cannot be discretized (it would drop the span semantics, MEOS +# errors), so this lifts an instant to a one-element discrete sequence, +# matching MobilityDB's 102_tpose reference for setInterp(...,'discrete'). +query I +SELECT tempSubtype(setInterp(tpose 'Pose(Point(1 1), 0.2)@2000-01-01', 'discrete')); +---- +Sequence + +# Test merge function +query I +SELECT numInstants(merge( + tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.3)@2000-01-02]', + tpose '[Pose(Point(1 1), 0.3)@2000-01-02, Pose(Point(1 1), 0.5)@2000-01-03]')); +---- +3 + +# Test tempSubtype with instant +query I +SELECT tempSubtype(tpose 'Pose(Point(1 1), 0.5)@2000-01-01'); +---- +Instant + +# Test tempSubtype with discrete sequence +query I +SELECT tempSubtype(tpose '{Pose(Point(1 1), 0.3)@2000-01-01, Pose(Point(1 1), 0.5)@2000-01-02}'); +---- +Sequence + +# Test tempSubtype with continuous sequence +query I +SELECT tempSubtype(tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]'); +---- +Sequence + +# Test tempSubtype with sequence set +query I +SELECT tempSubtype(tpose '{[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02], [Pose(Point(2 2), 0.6)@2000-01-04, Pose(Point(2 2), 0.6)@2000-01-05]}'); +---- +SequenceSet + +# Test memSize is positive +query I +SELECT memSize(tpose 'Pose(Point(1 1), 0.5)@2000-01-01') > 0; +---- +true + +# Test interp accessor +query I +SELECT interp(tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]'); +---- +Linear + +# Test getValue returns the pose value text +query I +SELECT getValue(tpose 'Pose(Point(1 1), 0.5)@2000-01-01'); +---- +Pose(POINT(1 1),0.5) + +# Test startValue +query I +SELECT startValue(tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]'); +---- +Pose(POINT(1 1),0.2) + +# Test endValue +query I +SELECT endValue(tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]'); +---- +Pose(POINT(1 1),0.4) + +# Test startInstant +query I +SELECT asText(startInstant(tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]')); +---- +Pose(POINT(1 1),0.2)@2000-01-01 00:00:00+01 + +# Test endInstant +query I +SELECT asText(endInstant(tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]')); +---- +Pose(POINT(1 1),0.4)@2000-01-02 00:00:00+01 + +# Test instantN +query I +SELECT asText(instantN(tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]', 1)); +---- +Pose(POINT(1 1),0.2)@2000-01-01 00:00:00+01 + +# Test getTimestamp function +query I +SELECT getTimestamp(tpose 'Pose(Point(1 1), 0.5)@2023-01-01 10:00:00+00'); +---- +2023-01-01 11:00:00+01 + +# Test numInstants generic accessor +query I +SELECT numInstants(tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02, Pose(Point(1 1), 0.5)@2000-01-03]'); +---- +3 + +# Test duration generic accessor +query I +SELECT duration(tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-03]'); +---- +2 days From cb39d262186d63729a9bbf72b14c557a436afb28 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Tue, 26 May 2026 09:06:49 +0200 Subject: [PATCH 5/6] Add the core trgeometry type port Bring the temporal rigid geometry (trgeometry) type into MobilityDuck: construction, text/EWKT/WKB I/O, casts and accessors, gated by the RGEO config flag that mirrors the MEOS RGEO build module. Disabling RGEO drops the trgeometry sources and its registration in LoadInternal. The MEOS calls use the trgeo_* names exported by the pinned MEOS; MFJSON input binds to a MEOS symbol the pinned MEOS does not yet expose, so it is omitted here. --- CMakeLists.txt | 8 + src/include/rgeo/trgeometry.hpp | 29 + src/mobilityduck_extension.cpp | 11 + src/rgeo/trgeometry.cpp | 1498 +++++++++++++++++++++++++++++++ src/rgeo/trgeometry_in_out.cpp | 439 +++++++++ test/sql/trgeometry.test | 201 +++++ 6 files changed, 2186 insertions(+) create mode 100644 src/include/rgeo/trgeometry.hpp create mode 100644 src/rgeo/trgeometry.cpp create mode 100644 src/rgeo/trgeometry_in_out.cpp create mode 100644 test/sql/trgeometry.test diff --git a/CMakeLists.txt b/CMakeLists.txt index 93c49957..b69b9eb0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -123,6 +123,14 @@ if(POSE) src/geo/tpose_in_out.cpp) endif() +option(RGEO "Build the trgeometry temporal type" ON) +if(RGEO) + add_definitions(-DRGEO=1) + list(APPEND EXTENSION_SOURCES + src/rgeo/trgeometry.cpp + src/rgeo/trgeometry_in_out.cpp) +endif() + build_static_extension(${TARGET_NAME} ${EXTENSION_SOURCES}) build_loadable_extension(${TARGET_NAME} "" ${EXTENSION_SOURCES}) diff --git a/src/include/rgeo/trgeometry.hpp b/src/include/rgeo/trgeometry.hpp new file mode 100644 index 00000000..125c41e4 --- /dev/null +++ b/src/include/rgeo/trgeometry.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include +#include "duckdb/common/exception.hpp" +#include "duckdb/common/string_util.hpp" +#include "duckdb/function/scalar_function.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include + +namespace duckdb { + + +struct TRGeometryTypes { + static LogicalType TRGEOMETRY(); + static LogicalType GEOMETRY(); + static void RegisterTypes(ExtensionLoader &loader); + static void RegisterScalarFunctions(ExtensionLoader &loader); + static void RegisterCastFunctions(ExtensionLoader &loader); + static void RegisterScalarInOutFunctions(ExtensionLoader &loader); +}; + +struct TrgeometryFunctions { + static bool StringToTrgeometry(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + static bool TrgeometryToString(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + static bool WkbBlobToGeometry(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); +}; + + +} // namespace duckdb diff --git a/src/mobilityduck_extension.cpp b/src/mobilityduck_extension.cpp index b6720555..cf03daf9 100644 --- a/src/mobilityduck_extension.cpp +++ b/src/mobilityduck_extension.cpp @@ -23,6 +23,9 @@ #if POSE #include "geo/tpose.hpp" #endif +#if RGEO +#include "rgeo/trgeometry.hpp" +#endif #include "geo/tgeometry.hpp" #include "geo/tgeometry_ops.hpp" #include "geo/tgeography.hpp" @@ -395,6 +398,14 @@ static void LoadInternal(ExtensionLoader &loader) { TPoseTypes::RegisterScalarInOutFunctions(loader); #endif + // Extended temporal type trgeometry (requires the MEOS RGEO module). +#if RGEO + TRGeometryTypes::RegisterScalarFunctions(loader); + TRGeometryTypes::RegisterTypes(loader); + TRGeometryTypes::RegisterCastFunctions(loader); + TRGeometryTypes::RegisterScalarInOutFunctions(loader); +#endif + SetTypes::RegisterTypes(loader); SetTypes::RegisterCastFunctions(loader); SetTypes::RegisterScalarFunctions(loader); diff --git a/src/rgeo/trgeometry.cpp b/src/rgeo/trgeometry.cpp new file mode 100644 index 00000000..89ab250c --- /dev/null +++ b/src/rgeo/trgeometry.cpp @@ -0,0 +1,1498 @@ +#include "rgeo/trgeometry.hpp" +#include "geo/tpose.hpp" +#include "geo/tgeompoint_functions.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include "duckdb/common/extension_type_info.hpp" +#include +#include +#include +#include "temporal/spanset.hpp" +#include "temporal/set.hpp" +#include "temporal/temporal_functions.hpp" +#include "geo/stbox.hpp" +#include "geo/geoset.hpp" +#include +#include "geo_util.hpp" +#include "spatial/spatial_types.hpp" +#include "mobilityduck/meos_exec_serial.hpp" + +extern "C" { + #include + #include + #include + #include + #include +} + +// The temporal rigid geometry module header meos_rgeo.h is deliberately +// NOT included. It is the only extended-type module header that declares +// an Interval-typed prototype (trgeo_append_tinstant), and pulling +// the MEOS `struct Interval` into a scope that also has `duckdb::Interval` +// (from tydef.hpp) makes the unqualified `Interval` ambiguous and breaks +// the build. The few trgeometry_* symbols this port needs are declared +// locally instead (the same technique the sibling ports use for +// subtype-specific parsers); GSERIALIZED / Pose / MeosType stay reachable +// via meos_geo.h / meos_internal.h / meos_pose.h. Every name below is +// the post-uniformization trgeometry_* name exported from meos_rgeo.h. +extern "C" { + extern Temporal *trgeo_in(const char *str); + extern TInstant *trgeoinst_make(const GSERIALIZED *geom, + const Pose *pose, TimestampTz t); + extern Temporal *geo_tpose_to_trgeo(const GSERIALIZED *gs, + const Temporal *temp); + extern GSERIALIZED *trgeo_geom(const Temporal *temp); + extern GSERIALIZED *trgeo_start_value(const Temporal *temp); + extern GSERIALIZED *trgeo_end_value(const Temporal *temp); + // Correct WKT parser for a temporal rigid geometry (see trgeometry_parse_wkt). + extern Temporal *trgeo_parse(const char **str, MeosType temptype); + // Instant accessors that preserve the (sequence-level shared) reference + // geometry. The generic temporal_*_instant return a bare pose instant with + // no geometry, so asText then fails "Cannot access geometry ...". + extern TInstant *trgeo_start_instant(const Temporal *temp); + extern TInstant *trgeo_end_instant(const Temporal *temp); + extern TInstant *trgeo_instant_n(const Temporal *temp, int n); +} + + +namespace duckdb { + +// MEOS BUG (pinned bb659c693): the public trgeo_in wrapper calls +// tspatial_parse (no reference-geometry handling), so a WKT trgeometry literal +// fails "parse error - invalid geometry". The correct, exported parser is +// trgeo_parse. Route to it until the pin includes the upstream one-line fix +// (trgeo_in must call trgeo_parse). +static inline Temporal *trgeometry_parse_wkt(const char *str) { + const char *p = str; + return trgeo_parse(&p, T_TRGEOMETRY); +} + +LogicalType TRGeometryTypes::TRGEOMETRY() { + auto type = LogicalType(LogicalTypeId::BLOB); + type.SetAlias("TRGEOMETRY"); + return type; +} + +/* + * Constructors +*/ + +inline void Trgeometry_constructor(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> string_t { + std::string input = input_geom_str.GetString(); + + // The temporal rigid geometry text form is a reference + // geometry, a ';' delimiter and a temporal pose, e.g. + // 'Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1),0.5)@2000-01-01'. + // 'Polygon(...);Pose@t' — parsed by trgeo_parse (the public + // trgeo_in wrapper is buggy on the pin; see trgeometry_parse_wkt). + Temporal *tinst = trgeometry_parse_wkt(input.c_str()); + if (!tinst) { + throw InvalidInputException("Invalid TRGEOMETRY input: " + input); + } + + size_t data_size = temporal_mem_size(tinst); + + uint8_t *data_buffer = (uint8_t*)malloc(data_size); + if (!data_buffer) { + free(tinst); + throw InvalidInputException("Failed to allocate memory for TRGEOMETRY data"); + } + + memcpy(data_buffer, tinst, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer), data_size); + string_t stored_data = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(tinst); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Trgeometryinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &geom_vec = args.data[0]; + auto &pose_vec = args.data[1]; + auto &t_vec = args.data[2]; + + TernaryExecutor::Execute( + geom_vec, pose_vec, t_vec, result, count, + [&](string_t geom_blob, string_t pose_str, timestamp_tz_t t) -> string_t { + // The reference geometry arrives as a GEOMETRY blob. + GSERIALIZED *gs = GeometryToGSerialized(geom_blob, 0); + if (gs == NULL) { + throw InvalidInputException("Invalid geometry for TRGEOMETRY"); + } + + // The pose value type is a Pose (position + orientation): + // a 2D pose is a point plus a rotation angle, a 3D pose a + // point plus an orientation quaternion. It is parsed from + // its canonical text form, e.g. 'Pose(Point(1 1), 0.5)'. + std::string pose_value = pose_str.GetString(); + Pose *po = pose_in(pose_value.c_str()); + if (po == NULL) { + free(gs); + throw InvalidInputException("Invalid pose format: " + pose_value); + } + + timestamp_tz_t meos_timestamp = DuckDBToMeosTimestamp(t); + // The rigid-geometry instant constructor pairs the reference + // geometry with the moving pose at the given timestamp. + TInstant *inst = trgeoinst_make(gs, po, + static_cast(meos_timestamp.value)); + + if (inst == NULL) { + free(po); + free(gs); + throw InvalidInputException("Failed to create TInstant"); + } + + size_t data_size = temporal_mem_size((Temporal*)inst); + + uint8_t *data_buffer = (uint8_t *)malloc(data_size); + + if (!data_buffer){ + free(inst); + free(po); + free(gs); + throw InvalidInputException("Failed to allocate memory to TRGEOMETRY data"); + } + memcpy(data_buffer, inst, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer),data_size); + string_t stored_data = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(inst); + free(po); + free(gs); + + return stored_data; + + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Geo_tpose_to_trgeometry(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &geom_vec = args.data[0]; + auto &tpose_vec = args.data[1]; + + BinaryExecutor::Execute( + geom_vec, tpose_vec, result, count, + [&](string_t geom_blob, string_t tpose_blob)-> string_t{ + // The reference geometry arrives as a GEOMETRY blob and the + // motion as a serialized temporal pose; the rigid geometry + // is the geometry moved by that temporal pose. + GSERIALIZED *gs = GeometryToGSerialized(geom_blob, 0); + if (gs == NULL) { + throw InvalidInputException("Invalid geometry for TRGEOMETRY"); + } + + std::string tpose_input = tpose_blob.GetString(); + Temporal *tpose = reinterpret_cast(const_cast(tpose_input.c_str())); + if (!tpose) { + free(gs); + throw InvalidInputException("Invalid TPOSE data: null pointer"); + } + + Temporal *temp = geo_tpose_to_trgeo(gs, tpose); + if (temp == NULL) { + free(gs); + throw InvalidInputException("Failed to create TRGEOMETRY"); + } + + size_t temp_size = temporal_mem_size(temp); + + uint8_t *temp_buffer = (uint8_t *)malloc(temp_size); + if (!temp_buffer) { + free(temp); + free(gs); + throw InvalidInputException("Failed to allocate memory for TRGEOMETRY data"); + } + + memcpy(temp_buffer, temp, temp_size); + + string_t temp_string_t((char*) temp_buffer, temp_size); + string_t stored_data = StringVector::AddStringOrBlob(result, temp_string_t); + + free(temp_buffer); + free(temp); + free(gs); + + return stored_data; + + }); + + if (count == 1){ + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +TInstant **temparr_extract_rg(Vector &trgeom_arr_vec, list_entry_t list_entry, int *count) { + auto &child_vector = ListVector::GetEntry(trgeom_arr_vec); + auto list_size = list_entry.length; + auto list_offset = list_entry.offset; + + if (list_size == 0) { + *count = 0; + return nullptr; + } + + *count = list_size; + + TInstant **instants = (TInstant**)malloc(sizeof(TInstant*) * list_size); + if (!instants) { + *count = 0; + return nullptr; + } + + for (idx_t i = 0; i < list_size; i++) { + auto element_idx = list_offset + i; + string_t tgeom_blob = FlatVector::GetData(child_vector)[element_idx]; + + const uint8_t *data = reinterpret_cast(tgeom_blob.GetData()); + size_t data_size = tgeom_blob.GetSize(); + + if (data_size < sizeof(void*)) { + for (idx_t j = 0; j < i; j++) { + if (instants[j]) free(instants[j]); + } + free(instants); + *count = 0; + return nullptr; + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + for (idx_t j = 0; j < i; j++) { + if (instants[j]) free(instants[j]); + } + free(instants); + *count = 0; + return nullptr; + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + if (!temp) { + free(data_copy); + for (idx_t j = 0; j < i; j++) { + if (instants[j]) free(instants[j]); + } + free(instants); + *count = 0; + return nullptr; + } + + instants[i] = (TInstant*)temp; + } + + return instants; +} + +inline void Trgeometry_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { + // Default values + const char* default_interp = "linear"; + bool default_lower_inc = true; + bool default_upper_inc = true; + + auto count = args.size(); + auto arg_count = args.ColumnCount(); + + + auto &trgeom_arr_vec = args.data[0]; + trgeom_arr_vec.Flatten(count); + + Vector *interp_vec = nullptr; + Vector *lower_vec = nullptr; + Vector *upper_vec = nullptr; + + if (arg_count > 1) { + interp_vec = &args.data[1]; + interp_vec->Flatten(count); + } + if (arg_count > 2) { + lower_vec = &args.data[2]; + lower_vec->Flatten(count); + } + if (arg_count > 3) { + upper_vec = &args.data[3]; + upper_vec->Flatten(count); + } + + result.Flatten(count); + + auto trgeom_data = FlatVector::GetData(trgeom_arr_vec); + auto result_data = FlatVector::GetData(result); + + // Get validity masks + auto &trgeom_validity = FlatVector::Validity(trgeom_arr_vec); + auto &result_validity = FlatVector::Validity(result); + + for (idx_t i = 0; i < count; i++) { + if (!trgeom_validity.RowIsValid(i)) { + result_validity.SetInvalid(i); + continue; + } + + try { + list_entry_t list_entry = trgeom_data[i]; + + // Handle interp parameter with default + std::string interp_str = default_interp; + if (interp_vec) { + auto interp_data = FlatVector::GetData(*interp_vec); + auto &interp_validity = FlatVector::Validity(*interp_vec); + if (interp_validity.RowIsValid(i)) { + interp_str = interp_data[i].GetString(); + } + } + interpType interp = interptype_from_string(interp_str.c_str()); + + bool lower_inc = default_lower_inc; + bool upper_inc = default_upper_inc; + + if (lower_vec) { + auto lower_data = FlatVector::GetData(*lower_vec); + auto &lower_validity = FlatVector::Validity(*lower_vec); + if (lower_validity.RowIsValid(i)) { + lower_inc = lower_data[i]; + } + } + + if (upper_vec) { + auto upper_data = FlatVector::GetData(*upper_vec); + auto &upper_validity = FlatVector::Validity(*upper_vec); + if (upper_validity.RowIsValid(i)) { + upper_inc = upper_data[i]; + } + } + + // Extract array elements + int element_count; + TInstant **instants = temparr_extract_rg(trgeom_arr_vec, list_entry, &element_count); + + if (!instants || element_count == 0) { + result_validity.SetInvalid(i); + continue; + } + + TSequence *sequence_result = tsequence_make((TInstant **) instants, element_count, + lower_inc, upper_inc, interp, true); + + if (!sequence_result) { + for (int j = 0; j < element_count; j++) { + if (instants[j]) { + free(instants[j]); + } + } + free(instants); + result_validity.SetInvalid(i); + continue; + } + + size_t data_size = temporal_mem_size(reinterpret_cast(sequence_result)); + uint8_t *data_buffer = (uint8_t*)malloc(data_size); + if (!data_buffer) { + free(sequence_result); + for (int j = 0; j < element_count; j++) { + if (instants[j]) { + free(instants[j]); + } + } + free(instants); + result_validity.SetInvalid(i); + continue; + } + + memcpy(data_buffer, sequence_result, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer), data_size); + result_data[i] = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(sequence_result); + for (int j = 0; j < element_count; j++) { + if (instants[j]) { + free(instants[j]); + } + } + free(instants); + + } catch (const std::exception& e) { + result_validity.SetInvalid(i); + } + } + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + + +/* + * Conversions +*/ + +inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + if (!temp) { + throw InvalidInputException("Invalid TRGEOMETRY data: null pointer"); + } + + Span *timespan = temporal_to_tstzspan(temp); + + if (!timespan) { + throw InvalidInputException("Failed to extract timespan from TRGEOMETRY"); + } + + size_t span_size = sizeof(Span); + + uint8_t *span_buffer = (uint8_t*)malloc(span_size); + if (!span_buffer) { + free(timespan); + throw InvalidInputException("Failed to allocate memory for timespan data"); + } + + memcpy(span_buffer, timespan, span_size); + + string_t span_string_t(reinterpret_cast(span_buffer), span_size); + string_t stored_data = StringVector::AddStringOrBlob(result, span_string_t); + + free(span_buffer); + free(timespan); + + return stored_data; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +/* + * Transformations +*/ + +inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + if (!temp) { + throw InvalidInputException("Invalid TRGEOMETRY data: null pointer"); + } + + TInstant *inst = temporal_to_tinstant(temp); + if (!inst) { + throw InvalidInputException("Failed to convert TRGEOMETRY to TInstant"); + } + + size_t inst_size = temporal_mem_size((Temporal*)inst); + + uint8_t *inst_buffer = (uint8_t*)malloc(inst_size); + if (!inst_buffer) { + free(inst); + throw InvalidInputException("Failed to allocate memory for TInstant data"); + } + + memcpy(inst_buffer, inst, inst_size); + + string_t inst_string_t(reinterpret_cast(inst_buffer), inst_size); + string_t stored_data = StringVector::AddStringOrBlob(result, inst_string_t); + + free(inst_buffer); + free(inst); + + return stored_data; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + auto &interp_vec = args.data[1]; + + tgeom_vec.Flatten(count); + interp_vec.Flatten(count); + + BinaryExecutor::Execute( + tgeom_vec, interp_vec, result, count, + [&](string_t tgeom_str_t, string_t interp_str_t) -> string_t { + + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TRGEOMETRY data: null pointer"); + } + + std::string interp_str = interp_str_t.GetString(); + interpType new_interp = interptype_from_string(interp_str.c_str()); + + Temporal *result_temp = temporal_set_interp(temp, new_interp); + if (!result_temp) { + throw InvalidInputException("Failed to set interpolation"); + } + + // Serialize result back to binary + size_t result_size = temporal_mem_size(result_temp); + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(result_temp); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, result_temp, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_data = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(result_temp); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom1_vec = args.data[0]; + auto &tgeom2_vec = args.data[1]; + + tgeom1_vec.Flatten(count); + tgeom2_vec.Flatten(count); + + BinaryExecutor::Execute( + tgeom1_vec, tgeom2_vec, result, count, + [&](string_t tgeom1_str_t, string_t tgeom2_str_t) -> string_t { + std::string tgeom1 = tgeom1_str_t.GetString(); + + Temporal *temp1 = reinterpret_cast(const_cast(tgeom1.c_str())); + if (!temp1) { + throw InvalidInputException("Invalid TRGEOMETRY data: null pointer"); + } + + std::string tgeom2 = tgeom2_str_t.GetString(); + + Temporal *temp2 = reinterpret_cast(const_cast(tgeom2.c_str())); + if (!temp2) { + throw InvalidInputException("Invalid TRGEOMETRY data: null pointer"); + } + + Temporal *result_temp = temporal_merge(temp1, temp2); + if (!result_temp) { + throw InvalidInputException("Failed to merge temporal rigid geometries"); + } + + // Serialize result back to binary + size_t result_size = temporal_mem_size(result_temp); + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(result_temp); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, result_temp, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_data = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(result_temp); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +/* + * Accessor Functions +*/ + +inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + + tgeom_vec.Flatten(count); + + UnaryExecutor::Execute( + tgeom_vec, result, count, + [&](string_t tgeom_str_t) -> string_t { + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TRGEOMETRY data: null pointer"); + } + + const char *subtype_str = temporal_subtype(temp); + if (!subtype_str) { + throw InvalidInputException("Failed to get temporal subtype"); + } + + std::string result_str(subtype_str); + string_t stored_result = StringVector::AddString(result, result_str); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + + +inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + + tgeom_vec.Flatten(count); + + UnaryExecutor::Execute( + tgeom_vec, result, count, + [&](string_t tgeom_str_t) -> string_t { + + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TRGEOMETRY data: null pointer"); + } + + + const char *interp_str = temporal_interp(temp); + if (!interp_str) { + throw InvalidInputException("Failed to get temporal interpolation"); + } + + std::string result_str(interp_str); + string_t stored_result = StringVector::AddString(result, result_str); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + + tgeom_vec.Flatten(count); + + UnaryExecutor::Execute( + tgeom_vec, result, count, + [&](string_t tgeom_str_t) -> int32_t { + std::string input = tgeom_str_t.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + if (!temp) { + throw InvalidInputException("Invalid TRGEOMETRY data: null pointer"); + } + + size_t mem_size = temporal_mem_size(temp); + + + return static_cast(mem_size); + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +// ---- Rigid-geometry value accessors ---- +// A temporal rigid geometry is a reference geometry rigidly moved over +// time by an embedded temporal pose, so its instant value type is a Pose +// (not a registered DuckDB type). getValue surfaces that pose in its +// canonical text form (`Pose(POINT(x y),theta)`), mirroring the asText +// output, exactly as the tpose port does. The reference geometry is +// surfaced by geometry(trgeometry) via trgeo_geom, and the moved +// rigid-geometry snapshot at the bounding instants is surfaced by +// startValue / endValue via trgeo_start_value / trgeo_end_value +// (each a freshly allocated GSERIALIZED the caller owns), per the +// canonical MobilityDB SQL signatures. + +inline Pose *pose_from_instant_value(const TInstant *inst) { + Datum d = tinstant_value(inst); + return reinterpret_cast(d); +} + +inline void Trgeometry_get_value(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + TInstant *tinst = reinterpret_cast(const_cast(input.c_str())); + + // tinstant_value returns a freshly allocated copy of the + // Pose value (datum_copy), which the caller owns. + Pose *po = pose_from_instant_value(tinst); + + char *str = pose_as_text(po, 15); + if (!str) { + free(po); + throw InvalidInputException("Failed to convert pose value to text"); + } + std::string output(str); + string_t stored_result = StringVector::AddString(result, output); + + free(str); + free(po); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + +inline void Trgeometry_start_value_exec(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + // trgeo_start_value returns a freshly allocated + // GSERIALIZED of the rigid-geometry snapshot at the first + // instant (the reference geometry moved by the start pose). + GSERIALIZED *gs = trgeo_start_value(temp); + if (!gs) { + throw InvalidInputException("Failed to extract start value from TRGEOMETRY"); + } + + string_t geometry_blob = GSerializedToGeometry(gs, state, result); + string_t stored_result = StringVector::AddStringOrBlob(result, geometry_blob); + + free(gs); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Trgeometry_end_value_exec(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + // trgeo_end_value returns a freshly allocated + // GSERIALIZED of the rigid-geometry snapshot at the last + // instant (the reference geometry moved by the end pose). + GSERIALIZED *gs = trgeo_end_value(temp); + if (!gs) { + throw InvalidInputException("Failed to extract end value from TRGEOMETRY"); + } + + string_t geometry_blob = GSerializedToGeometry(gs, state, result); + string_t stored_result = StringVector::AddStringOrBlob(result, geometry_blob); + + free(gs); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Trgeometry_geom(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + // trgeo_geom returns a freshly allocated GSERIALIZED + // copy of the reference geometry that is rigidly moved. + GSERIALIZED *gs = trgeo_geom(temp); + if (!gs) { + throw InvalidInputException("Failed to extract reference geometry from TRGEOMETRY"); + } + + string_t geometry_blob = GSerializedToGeometry(gs, state, result); + string_t stored_result = StringVector::AddStringOrBlob(result, geometry_blob); + + free(gs); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal* temp = reinterpret_cast(const_cast(input.c_str())); + + bool lower_inc = temporal_lower_inc(temp); + + std::string result_str = lower_inc ? "true" : "false"; + string_t stored_result = StringVector::AddString(result, result_str); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal* temp = reinterpret_cast(const_cast(input.c_str())); + + bool upper_inc = temporal_upper_inc(temp); + + std::string result_str = upper_inc ? "true" : "false"; + string_t stored_result = StringVector::AddString(result, result_str); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Trgeometry_start_instant_exec(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + TInstant *start_inst = trgeo_start_instant(temp); + + if (!start_inst) { + throw InvalidInputException("Failed to get start_inst from temporal object"); + } + + size_t result_size = temporal_mem_size((Temporal*)start_inst); + if (result_size == 0) { + throw InvalidInputException("Invalid result size from temporal object"); + } + + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(start_inst); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, start_inst, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_result = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(start_inst); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Trgeometry_end_instant_exec(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_vec = args.data[0]; + + UnaryExecutor::Execute( + input_vec, result, count, + [&](string_t input_str) -> string_t { + std::string input = input_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(input.c_str())); + + TInstant *end_inst = trgeo_end_instant(temp); + + if (!end_inst) { + throw InvalidInputException("Failed to get end_inst from temporal object"); + } + + size_t result_size = temporal_mem_size((Temporal*)end_inst); + if (result_size == 0) { + throw InvalidInputException("Invalid result size from temporal object"); + } + + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(end_inst); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, end_inst, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_result = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(end_inst); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + + + +inline void Trgeometry_instant_n_exec(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &tgeom_vec = args.data[0]; + auto &n_vec = args.data[1]; + + BinaryExecutor::Execute( + tgeom_vec, n_vec, result, count, + [&](string_t tgeom_str, int32_t n) -> string_t { + std::string tgeom = tgeom_str.GetString(); + + Temporal *temp = reinterpret_cast(const_cast(tgeom.c_str())); + + TInstant *inst_n = trgeo_instant_n(temp, n); + if (!inst_n) { + throw InvalidInputException("Failed to get instant n from temporal object"); + } + + size_t result_size = temporal_mem_size((Temporal*)inst_n); + if (result_size == 0) { + throw InvalidInputException("Invalid result size from temporal object"); + } + + uint8_t *result_buffer = (uint8_t*)malloc(result_size); + if (!result_buffer) { + free(inst_n); + throw InvalidInputException("Failed to allocate memory for result"); + } + + memcpy(result_buffer, inst_n, result_size); + string_t result_string_t(reinterpret_cast(result_buffer), result_size); + string_t stored_result = StringVector::AddStringOrBlob(result, result_string_t); + + free(result_buffer); + free(inst_n); + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> timestamp_tz_t { + const uint8_t *data = reinterpret_cast(input_geom_str.GetData()); + size_t data_size = input_geom_str.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TRGEOMETRY data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TRGEOMETRY deserialization"); + } + memcpy(data_copy, data, data_size); + + TInstant *temp = reinterpret_cast(data_copy); + + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TRGEOMETRY data: null pointer"); + } + + TimestampTz meos_t = temp->t; + + timestamp_tz_t meos_timestamp{meos_t}; + timestamp_tz_t duckdb_t = MeosToDuckDBTimestamp(meos_timestamp); + + free(data_copy); + + return duckdb_t; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +void TRGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { + + auto trgeometry_function = ScalarFunction( + "TRGEOMETRY", + {LogicalType::VARCHAR}, + TRGeometryTypes::TRGEOMETRY(), + Trgeometry_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, trgeometry_function); + + auto trgeometry_inst_function = ScalarFunction( + "TRGEOMETRY", + {GeoTypes::GEOMETRY(), LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ}, + TRGeometryTypes::TRGEOMETRY(), + Trgeometryinst_constructor); + duckdb::RegisterSerializedScalarFunction(loader, trgeometry_inst_function); + + // trgeometry(geometry, tpose): the reference geometry moved by a temporal + // pose. The second argument is a TPOSE (the exec reads it as the serialized + // temporal pose), not VARCHAR — tpose is a registered type in the accumulate. + auto trgeometry_from_tpose_function = ScalarFunction( + "TRGEOMETRY", + {GeoTypes::GEOMETRY(), TPoseTypes::TPOSE()}, + TRGeometryTypes::TRGEOMETRY(), + Geo_tpose_to_trgeometry + ); + duckdb::RegisterSerializedScalarFunction(loader, trgeometry_from_tpose_function); + + auto trgeometryseqarr_1param= ScalarFunction( + "trgeometrySeq", + {LogicalType::LIST(TRGeometryTypes::TRGEOMETRY())}, + TRGeometryTypes::TRGEOMETRY(), + Trgeometry_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, trgeometryseqarr_1param); + + auto trgeometryseqarr_2params = ScalarFunction( + "trgeometrySeq", + {LogicalType::LIST(TRGeometryTypes::TRGEOMETRY()), LogicalType::VARCHAR}, + TRGeometryTypes::TRGEOMETRY(), + Trgeometry_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, trgeometryseqarr_2params); + + auto trgeometryseqarr_3params = ScalarFunction( + "trgeometrySeq", + {LogicalType::LIST(TRGeometryTypes::TRGEOMETRY()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, + TRGeometryTypes::TRGEOMETRY(), + Trgeometry_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, trgeometryseqarr_3params); + + auto trgeometryseqarr_4params = ScalarFunction( + "trgeometrySeq", + {LogicalType::LIST(TRGeometryTypes::TRGEOMETRY()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, + TRGeometryTypes::TRGEOMETRY(), + Trgeometry_sequence_constructor + ); + duckdb::RegisterSerializedScalarFunction(loader, trgeometryseqarr_4params); + + auto trgeometry_to_timespan_function = ScalarFunction( + "timeSpan", + {TRGeometryTypes::TRGEOMETRY()}, + SpanTypes::TSTZSPAN(), + Temporal_to_tstzspan); + duckdb::RegisterSerializedScalarFunction(loader, trgeometry_to_timespan_function); + + auto trgeometry_to_tinstant_function = ScalarFunction( + "trgeometryInst", + {TRGeometryTypes::TRGEOMETRY()}, + TRGeometryTypes::TRGEOMETRY(), + Temporal_to_tinstant); + duckdb::RegisterSerializedScalarFunction(loader, trgeometry_to_tinstant_function); + + + auto setInterp_function = ScalarFunction( + "setInterp", + {TRGeometryTypes::TRGEOMETRY(), LogicalType::VARCHAR}, + TRGeometryTypes::TRGEOMETRY(), + Temporal_set_interp + ); + duckdb::RegisterSerializedScalarFunction(loader, setInterp_function); + + + auto merge_function = ScalarFunction( + "merge", + {TRGeometryTypes::TRGEOMETRY(), TRGeometryTypes::TRGEOMETRY()}, + TRGeometryTypes::TRGEOMETRY(), + Temporal_merge + ); + duckdb::RegisterSerializedScalarFunction(loader, merge_function); + + auto tempSubtype_function = ScalarFunction( + "tempSubtype", + {TRGeometryTypes::TRGEOMETRY()}, + LogicalType::VARCHAR, + Temporal_subtype + ); + duckdb::RegisterSerializedScalarFunction(loader, tempSubtype_function); + + auto interp_function = ScalarFunction( + "interp", + {TRGeometryTypes::TRGEOMETRY()}, + LogicalType::VARCHAR, + Temporal_interp + ); + duckdb::RegisterSerializedScalarFunction(loader, interp_function); + + auto memSize_function = ScalarFunction( + "memSize", + {TRGeometryTypes::TRGEOMETRY()}, + LogicalType::INTEGER, + Temporal_mem_size + ); + duckdb::RegisterSerializedScalarFunction(loader, memSize_function); + + auto getValue_function = ScalarFunction( + "getValue", + {TRGeometryTypes::TRGEOMETRY()}, + LogicalType::VARCHAR, + Trgeometry_get_value + ); + duckdb::RegisterSerializedScalarFunction(loader, getValue_function); + + + auto trgeometry_start_value_function = ScalarFunction( + "startValue", + {TRGeometryTypes::TRGEOMETRY()}, + GeoTypes::GEOMETRY(), + Trgeometry_start_value_exec + ); + duckdb::RegisterSerializedScalarFunction(loader, trgeometry_start_value_function); + + auto trgeometry_end_value_function = ScalarFunction( + "endValue", + {TRGeometryTypes::TRGEOMETRY()}, + GeoTypes::GEOMETRY(), + Trgeometry_end_value_exec + ); + duckdb::RegisterSerializedScalarFunction(loader, trgeometry_end_value_function); + + auto trgeometry_geom_function = ScalarFunction( + "geometry", + {TRGeometryTypes::TRGEOMETRY()}, + GeoTypes::GEOMETRY(), + Trgeometry_geom + ); + duckdb::RegisterSerializedScalarFunction(loader, trgeometry_geom_function); + + auto startInstant_function = ScalarFunction( + "startInstant", + {TRGeometryTypes::TRGEOMETRY()}, + TRGeometryTypes::TRGEOMETRY(), + Trgeometry_start_instant_exec + ); + duckdb::RegisterSerializedScalarFunction(loader, startInstant_function); + + auto endInstant_function = ScalarFunction( + "endInstant", + {TRGeometryTypes::TRGEOMETRY()}, + TRGeometryTypes::TRGEOMETRY(), + Trgeometry_end_instant_exec + ); + duckdb::RegisterSerializedScalarFunction(loader, endInstant_function); + + auto instantN_function = ScalarFunction( + "instantN", + {TRGeometryTypes::TRGEOMETRY(), LogicalType::INTEGER}, + TRGeometryTypes::TRGEOMETRY(), + Trgeometry_instant_n_exec + ); + duckdb::RegisterSerializedScalarFunction(loader, instantN_function); + + + auto trgeometry_gettimestamptz_function = ScalarFunction( + "getTimestamp", + {TRGeometryTypes::TRGEOMETRY()}, + LogicalType::TIMESTAMP_TZ, + Tinstant_timestamptz); + duckdb::RegisterSerializedScalarFunction(loader, trgeometry_gettimestamptz_function); + + + // =================================================================== + // Foundational trgeometry surface — accessors, time/value-restrict, + // modifiers, and comparison. The MEOS C functions delegated to here + // are subtype-agnostic (they take Temporal *), so we reuse the same + // generic handlers wired for tgeompoint in temporal_functions.cpp. + // =================================================================== + + const LogicalType TGEOM = TRGeometryTypes::TRGEOMETRY(); + const LogicalType TSTZ = LogicalType::TIMESTAMP_TZ; + const LogicalType IVAL = LogicalType::INTERVAL; + + // ---- Accessors ---- + loader.RegisterFunction(ScalarFunction( + "valueAtTimestamp", {TGEOM, TSTZ}, LogicalType::VARCHAR, + Trgeometry_get_value)); + loader.RegisterFunction(ScalarFunction( + "getTime", {TGEOM}, SpansetTypes::tstzspanset(), + TemporalFunctions::Temporal_time)); + loader.RegisterFunction(ScalarFunction( + "duration", {TGEOM}, IVAL, + TemporalFunctions::Temporal_duration)); + loader.RegisterFunction(ScalarFunction( + "duration", {TGEOM, LogicalType::BOOLEAN}, IVAL, + TemporalFunctions::Temporal_duration)); + loader.RegisterFunction(ScalarFunction( + "lowerInc", {TGEOM}, LogicalType::BOOLEAN, + TemporalFunctions::Temporal_lower_inc)); + loader.RegisterFunction(ScalarFunction( + "upperInc", {TGEOM}, LogicalType::BOOLEAN, + TemporalFunctions::Temporal_upper_inc)); + loader.RegisterFunction(ScalarFunction( + "numInstants", {TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_num_instants)); + loader.RegisterFunction(ScalarFunction( + "instants", {TGEOM}, LogicalType::LIST(TGEOM), + TemporalFunctions::Temporal_instants)); + loader.RegisterFunction(ScalarFunction( + "numSequences", {TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_num_sequences)); + loader.RegisterFunction(ScalarFunction( + "sequences", {TGEOM}, LogicalType::LIST(TGEOM), + TemporalFunctions::Temporal_sequences)); + loader.RegisterFunction(ScalarFunction( + "startSequence", {TGEOM}, TGEOM, + TemporalFunctions::Temporal_start_sequence)); + loader.RegisterFunction(ScalarFunction( + "endSequence", {TGEOM}, TGEOM, + TemporalFunctions::Temporal_end_sequence)); + loader.RegisterFunction(ScalarFunction( + "sequenceN", {TGEOM, LogicalType::INTEGER}, TGEOM, + TemporalFunctions::Temporal_sequence_n)); + loader.RegisterFunction(ScalarFunction( + "numTimestamps", {TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_num_timestamps)); + loader.RegisterFunction(ScalarFunction( + "timestamps", {TGEOM}, LogicalType::LIST(TSTZ), + TemporalFunctions::Temporal_timestamps)); + loader.RegisterFunction(ScalarFunction( + "startTimestamp", {TGEOM}, TSTZ, + TemporalFunctions::Temporal_start_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "endTimestamp", {TGEOM}, TSTZ, + TemporalFunctions::Temporal_end_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "timestampN", {TGEOM, LogicalType::INTEGER}, TSTZ, + TemporalFunctions::Temporal_timestamptz_n)); + loader.RegisterFunction(ScalarFunction( + "segments", {TGEOM}, LogicalType::LIST(TGEOM), + TemporalFunctions::Temporal_segments)); + + // ---- Time-domain restrict / minus ---- + for (const auto &t : std::vector>{ + {TSTZ, TemporalFunctions::Temporal_at_timestamptz}, + {SetTypes::tstzset(), TemporalFunctions::Temporal_at_tstzset}, + {SpanTypes::TSTZSPAN(), TemporalFunctions::Temporal_at_tstzspan}, + {SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_at_tstzspanset}}) { + loader.RegisterFunction(ScalarFunction( + "atTime", {TGEOM, t.first}, TGEOM, t.second)); + } + for (const auto &t : std::vector>{ + {TSTZ, TemporalFunctions::Temporal_minus_timestamptz}, + {SetTypes::tstzset(), TemporalFunctions::Temporal_minus_tstzset}, + {SpanTypes::TSTZSPAN(), TemporalFunctions::Temporal_minus_tstzspan}, + {SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_minus_tstzspanset}}) { + loader.RegisterFunction(ScalarFunction( + "minusTime", {TGEOM, t.first}, TGEOM, t.second)); + } + + // beforeTimestamp / afterTimestamp accept timestamptz + loader.RegisterFunction(ScalarFunction( + "beforeTimestamp", {TGEOM, TSTZ}, TGEOM, + TemporalFunctions::Temporal_before_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "afterTimestamp", {TGEOM, TSTZ}, TGEOM, + TemporalFunctions::Temporal_after_timestamptz)); + + // ---- Modifiers (shift / scale / shiftScale / append / insert / update / + // delete) ---- + loader.RegisterFunction(ScalarFunction( + "shiftTime", {TGEOM, IVAL}, TGEOM, + TemporalFunctions::Temporal_shift_time)); + loader.RegisterFunction(ScalarFunction( + "scaleTime", {TGEOM, IVAL}, TGEOM, + TemporalFunctions::Temporal_scale_time)); + loader.RegisterFunction(ScalarFunction( + "shiftScaleTime", {TGEOM, IVAL, IVAL}, TGEOM, + TemporalFunctions::Temporal_shift_scale_time)); + loader.RegisterFunction(ScalarFunction( + "appendInstant", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_append_tinstant)); + loader.RegisterFunction(ScalarFunction( + "appendSequence", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_append_tsequence)); + loader.RegisterFunction(ScalarFunction( + "insert", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_insert)); + loader.RegisterFunction(ScalarFunction( + "insert", {TGEOM, TGEOM, LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_insert)); + loader.RegisterFunction(ScalarFunction( + "update", {TGEOM, TGEOM}, TGEOM, + TemporalFunctions::Temporal_update)); + loader.RegisterFunction(ScalarFunction( + "update", {TGEOM, TGEOM, LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_update)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, TSTZ}, TGEOM, + TemporalFunctions::Temporal_delete_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, TSTZ, LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_timestamptz)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SetTypes::tstzset()}, TGEOM, + TemporalFunctions::Temporal_delete_tstzset)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SetTypes::tstzset(), LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_tstzset)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpanTypes::TSTZSPAN()}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspan)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpanTypes::TSTZSPAN(), LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspan)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpansetTypes::tstzspanset()}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspanset)); + loader.RegisterFunction(ScalarFunction( + "deleteTime", {TGEOM, SpansetTypes::tstzspanset(), LogicalType::BOOLEAN}, TGEOM, + TemporalFunctions::Temporal_delete_tstzspanset)); + + // ---- Comparison (named functions + operators) ---- + struct CmpEntry { + const char *name; + scalar_function_t fn; + }; + const std::vector named_cmps = { + {"temporal_eq", TemporalFunctions::Temporal_eq}, + {"temporal_ne", TemporalFunctions::Temporal_ne}, + {"temporal_lt", TemporalFunctions::Temporal_lt}, + {"temporal_le", TemporalFunctions::Temporal_le}, + {"temporal_gt", TemporalFunctions::Temporal_gt}, + {"temporal_ge", TemporalFunctions::Temporal_ge}, + }; + for (const auto &c : named_cmps) { + loader.RegisterFunction(ScalarFunction( + c.name, {TGEOM, TGEOM}, LogicalType::BOOLEAN, c.fn)); + } + loader.RegisterFunction(ScalarFunction( + "temporal_cmp", {TGEOM, TGEOM}, LogicalType::INTEGER, + TemporalFunctions::Temporal_cmp)); + + // Operator forms — mirror the registrations tgeometry.cpp does. + const std::vector op_cmps = { + {"=", TemporalFunctions::Temporal_eq}, + {"<>", TemporalFunctions::Temporal_ne}, + {"<", TemporalFunctions::Temporal_lt}, + {"<=", TemporalFunctions::Temporal_le}, + {">", TemporalFunctions::Temporal_gt}, + {">=", TemporalFunctions::Temporal_ge}, + }; + for (const auto &c : op_cmps) { + loader.RegisterFunction(ScalarFunction( + c.name, {TGEOM, TGEOM}, LogicalType::BOOLEAN, c.fn)); + } +} + +void TRGeometryTypes::RegisterTypes(ExtensionLoader &loader) { + loader.RegisterType( "TRGEOMETRY", TRGeometryTypes::TRGEOMETRY()); +} + + +} diff --git a/src/rgeo/trgeometry_in_out.cpp b/src/rgeo/trgeometry_in_out.cpp new file mode 100644 index 00000000..3f7c1a16 --- /dev/null +++ b/src/rgeo/trgeometry_in_out.cpp @@ -0,0 +1,439 @@ +#include "rgeo/trgeometry.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include "duckdb/common/extension_type_info.hpp" +#include +#include +#include +#include "mobilityduck/meos_exec_serial.hpp" + +extern "C" { + #include + #include + #include + #include + #include +} + +// meos_rgeo.h is intentionally not included (its trgeo_append_tinstant +// prototype takes a MEOS Interval, which collides with duckdb::Interval). +// Declare only the trgeometry_* I/O symbols this translation unit needs; +// every name is the post-uniformization symbol exported from meos_rgeo.h. +extern "C" { + extern Temporal *trgeo_in(const char *str); + extern char *trgeo_out(const Temporal *temp); + // trgeo_parse is the correct WKT parser for a temporal rigid geometry + // ('Geometry;Pose@t...'): it parses the reference geometry first (split on + // ';') then the temporal pose. It is exported from libmeos (declared in + // the internal rgeo/trgeo_parser.h). See trgeometry_parse_wkt below. + extern Temporal *trgeo_parse(const char **str, MeosType temptype); + // WKT/EWKT output for a temporal rigid geometry ('geometry;pose' with the + // reference geometry as WKT). trgeo_out (above) emits the HexWKB geom + // form; asText/asEWKT need this WKT form (MobilityDB's Trgeometry_as_text / + // Trgeometry_as_ewkt wrap it with extended=false/true). meos_rgeo.h does + // not expose it, but it is exported from libmeos (internal trgeo.c). + extern char *trgeo_wkt_out(const Temporal *temp, int maxdd, bool extended); +} + +namespace duckdb { + +// MEOS BUG (pinned bb659c693): the public trgeo_in wrapper calls +// tspatial_parse, which has no reference-geometry handling, so any WKT +// trgeometry literal fails "parse error - invalid geometry". The correct +// (and exported) parser is trgeo_parse. Route to it directly until the pin +// includes the upstream one-line fix (trgeo_in must call trgeo_parse). +static inline Temporal *trgeometry_parse_wkt(const char *str) { + const char *p = str; + return trgeo_parse(&p, T_TRGEOMETRY); +} + +inline void Trgeometry_as_text_exec(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> string_t { + const uint8_t *data = reinterpret_cast(input_geom_str.GetData()); + size_t data_size = input_geom_str.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TRGEOMETRY data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TRGEOMETRY deserialization"); + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TRGEOMETRY data: null pointer"); + } + + // asText: reference geometry as WKT, a ';' delimiter, then the + // temporal pose. trgeo_wkt_out(extended=false) builds exactly that + // (trgeo_out emits the HexWKB geom form instead). + char *str = trgeo_wkt_out(temp, 15, false); + + if (!str) { + free(data_copy); + throw InvalidInputException("Failed to convert TRGEOMETRY to text"); + } + + std::string result_str(str); + string_t stored_result = StringVector::AddString(result, result_str); + + free(str); + free(data_copy); + + return stored_result; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + +inline void Trgeometry_as_ewkt_exec(DataChunk &args, ExpressionState &state, Vector &result) { + auto count = args.size(); + auto &input_geom_vec = args.data[0]; + + UnaryExecutor::Execute( + input_geom_vec, result, count, + [&](string_t input_geom_str) -> string_t { + + const uint8_t *data = reinterpret_cast(input_geom_str.GetData()); + size_t data_size = input_geom_str.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TRGEOMETRY data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TRGEOMETRY deserialization"); + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TRGEOMETRY data: null pointer"); + } + + // asEWKT: like asText but the reference geometry carries its SRID + // prefix. trgeo_wkt_out(extended=true) builds the rigid-geometry + // EWKT (the generic tspatial_as_ewkt drops the reference geometry). + char *ewkt = trgeo_wkt_out(temp, 15, true); + + if (!ewkt) { + free(data_copy); + throw InvalidInputException("Failed to convert TRGEOMETRY to EWKT"); + } + + std::string result_str(ewkt); + string_t stored_result = StringVector::AddString(result, result_str); + + + free(ewkt); + free(data_copy); + + return stored_result; + } + ); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } +} + + +bool TrgeometryFunctions::StringToTrgeometry(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { + UnaryExecutor::Execute( + source, result, count, + [&](string_t input_string) -> string_t { + std::string input_str = input_string.GetString(); + + Temporal *temp = trgeometry_parse_wkt(input_str.c_str()); + if (!temp) { + throw InvalidInputException("Invalid TRGEOMETRY input: " + input_str); + } + + size_t data_size = temporal_mem_size(temp); + uint8_t *data_buffer = (uint8_t*)malloc(data_size); + if (!data_buffer) { + free(temp); + throw InvalidInputException("Failed to allocate memory for TRGEOMETRY data"); + } + + memcpy(data_buffer, temp, data_size); + + string_t data_string_t(reinterpret_cast(data_buffer), data_size); + string_t stored_data = StringVector::AddStringOrBlob(result, data_string_t); + + free(data_buffer); + free(temp); + + return stored_data; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } + return true; +} + +bool TrgeometryFunctions::TrgeometryToString(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { + UnaryExecutor::Execute( + source, result, count, + [&](string_t input_blob) -> string_t { + const uint8_t *data = reinterpret_cast(input_blob.GetData()); + size_t data_size = input_blob.GetSize(); + + if (data_size < sizeof(void*)) { + throw InvalidInputException("Invalid TRGEOMETRY data: insufficient size"); + } + + uint8_t *data_copy = (uint8_t*)malloc(data_size); + if (!data_copy) { + throw InvalidInputException("Failed to allocate memory for TRGEOMETRY deserialization"); + } + memcpy(data_copy, data, data_size); + + Temporal *temp = reinterpret_cast(data_copy); + if (!temp) { + free(data_copy); + throw InvalidInputException("Invalid TRGEOMETRY data: null pointer"); + } + + char *str = trgeo_out(temp); + if (!str) { + free(data_copy); + throw InvalidInputException("Failed to convert TRGEOMETRY to string"); + } + + std::string output(str); + string_t stored_result = StringVector::AddString(result, output); + + free(str); + free(data_copy); + + return stored_result; + }); + + if (count == 1) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); + } + return true; +} + +// ---- Spatial-temporal parsers (Binary / HexWKB / MFJSON / Text) ---- +// Used to register the `trgeometryFrom*` overloads. +// `temporal_from_wkb` and `temporal_from_hexwkb` are subtype-agnostic; +// `trgeo_in` and `trgeometry_from_mfjson` are the renamed, +// header-exported per-type entry points (post API-uniformization they +// are real linkable symbols, so this is a clean clone of the canonical +// template rather than a tspatial_parse work-around). The result is +// stored as a raw blob, the same format every other temporal type uses. + +inline string_t StoreTempAsBlob(Vector &result, Temporal *t) { + size_t sz = temporal_mem_size(t); + string_t stored = StringVector::AddStringOrBlob( + result, string_t(reinterpret_cast(t), sz)); + free(t); + return stored; +} + +inline void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + if (input.GetSize() == 0) + throw InvalidInputException("fromBinary: empty WKB input"); + uint8_t *wkb = (uint8_t *)malloc(input.GetSize()); + if (!wkb) throw InternalException("fromBinary: malloc failed"); + memcpy(wkb, input.GetData(), input.GetSize()); + Temporal *t = temporal_from_wkb(wkb, input.GetSize()); + free(wkb); + if (!t) throw InvalidInputException("fromBinary: invalid MEOS-WKB"); + return StoreTempAsBlob(result, t); + }); +} + +inline void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + std::string hex(input.GetData(), input.GetSize()); + Temporal *t = temporal_from_hexwkb(hex.c_str()); + if (!t) throw InvalidInputException( + "fromHexWKB: invalid hex-encoded MEOS-WKB"); + return StoreTempAsBlob(result, t); + }); +} + +inline void TrgeometryFromTextExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + std::string s(input.GetData(), input.GetSize()); + Temporal *t = trgeometry_parse_wkt(s.c_str()); + if (!t) throw InvalidInputException("from*: invalid input"); + return StoreTempAsBlob(result, t); + }); +} + + +// Output serialization for trgeometry: asMFJSON (temporal_as_mfjson) and +// asBinary/asEWKB/asHexWKB/asHexEWKB (temporal_as_wkb / temporal_as_hexwkb). +// MobilityDB exposes all of these for trgeometry; the #153 port shipped only +// the From* parsers. Uniquely named per the ODR caveat. WKB_BASE (no SRID) is +// local; WKB_EXTENDED from meos_geo.h. +constexpr uint8_t WKB_BASE = 0x00; + +static Temporal *TrgeometryBlobToTemp(const string_t &blob) { + uint8_t *copy = (uint8_t *)malloc(blob.GetSize()); + if (!copy) throw InternalException("trgeometry blob->temporal: malloc failed"); + memcpy(copy, blob.GetData(), blob.GetSize()); + return reinterpret_cast(copy); +} + +void TrgeometryAsMfjsonExec(DataChunk &args, ExpressionState &state, Vector &result) { + const idx_t row_count = args.size(); + for (idx_t i = 0; i < args.ColumnCount(); i++) args.data[i].Flatten(row_count); + auto in = FlatVector::GetData(args.data[0]); + auto out_data = FlatVector::GetData(result); + auto &out_validity = FlatVector::Validity(result); + const idx_t cc = args.ColumnCount(); + for (idx_t row = 0; row < row_count; row++) { + if (!FlatVector::Validity(args.data[0]).RowIsValid(row)) { + out_validity.SetInvalid(row); + continue; + } + Temporal *t = TrgeometryBlobToTemp(in[row]); + bool with_bbox = (cc > 1) ? FlatVector::GetData(args.data[1])[row] : false; + int flags = (cc > 2) ? FlatVector::GetData(args.data[2])[row] : 0; + int precision = (cc > 3) ? FlatVector::GetData(args.data[3])[row] : 15; + std::string srs; + const char *srs_cstr = nullptr; + if (cc > 4) { + string_t s = FlatVector::GetData(args.data[4])[row]; + srs.assign(s.GetData(), s.GetSize()); + srs_cstr = srs.empty() ? nullptr : srs.c_str(); + } + char *json = temporal_as_mfjson(t, with_bbox, flags, precision, srs_cstr); + free(t); + if (!json) { out_validity.SetInvalid(row); continue; } + out_data[row] = StringVector::AddString(result, json); + free(json); + } + if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); +} + +void TrgeometryAsWkbExec(DataChunk &args, ExpressionState &state, Vector &result, uint8_t variant) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + Temporal *t = TrgeometryBlobToTemp(input); + size_t sz = 0; + uint8_t *wkb = temporal_as_wkb(t, variant, &sz); + free(t); + if (!wkb || sz == 0) { + if (wkb) free(wkb); + throw InternalException("temporal_as_wkb returned null"); + } + string_t blob(reinterpret_cast(wkb), sz); + string_t stored = StringVector::AddStringOrBlob(result, blob); + free(wkb); + return stored; + }); +} + +void TrgeometryAsHexWkbExec(DataChunk &args, ExpressionState &state, Vector &result, uint8_t variant) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + Temporal *t = TrgeometryBlobToTemp(input); + size_t sz = 0; + char *hex = temporal_as_hexwkb(t, variant, &sz); + (void) sz; + free(t); + if (!hex) throw InternalException("temporal_as_hexwkb returned null"); + string_t stored = StringVector::AddString(result, hex); + free(hex); + return stored; + }); +} + +void TRGeometryTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ + auto TrgeometryAsText = ScalarFunction( + "asText", + {TRGeometryTypes::TRGEOMETRY()}, + LogicalType::VARCHAR, + Trgeometry_as_text_exec + ); + duckdb::RegisterSerializedScalarFunction(loader, TrgeometryAsText); + + auto TrgeometryAsEWKT = ScalarFunction( + "asEWKT", + {TRGeometryTypes::TRGEOMETRY()}, + LogicalType::VARCHAR, + Trgeometry_as_ewkt_exec + ); + duckdb::RegisterSerializedScalarFunction(loader, TrgeometryAsEWKT); + + // ---- trgeometryFromBinary / FromEWKB (auto-detects format) ---- + const auto B = LogicalType::BLOB; + const auto V = LogicalType::VARCHAR; + const auto T = TRGeometryTypes::TRGEOMETRY(); + const auto BL = LogicalType::BOOLEAN; + const auto I = LogicalType::INTEGER; + + // asMFJSON(trgeometry[, with_bbox[, flags[, precision[, srs]]]]) + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("asMFJSON", {T}, V, TrgeometryAsMfjsonExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("asMFJSON", {T, BL}, V, TrgeometryAsMfjsonExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("asMFJSON", {T, BL, I}, V, TrgeometryAsMfjsonExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("asMFJSON", {T, BL, I, I}, V, TrgeometryAsMfjsonExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("asMFJSON", {T, BL, I, I, V}, V, TrgeometryAsMfjsonExec)); + + // asBinary / asEWKB and asHexWKB / asHexEWKB + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asBinary", {T}, B, + [](DataChunk &a, ExpressionState &s, Vector &r) { TrgeometryAsWkbExec(a, s, r, WKB_BASE); })); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asEWKB", {T}, B, + [](DataChunk &a, ExpressionState &s, Vector &r) { TrgeometryAsWkbExec(a, s, r, WKB_EXTENDED); })); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {T}, V, + [](DataChunk &a, ExpressionState &s, Vector &r) { TrgeometryAsHexWkbExec(a, s, r, WKB_BASE); })); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asHexEWKB", {T}, V, + [](DataChunk &a, ExpressionState &s, Vector &r) { TrgeometryAsHexWkbExec(a, s, r, WKB_EXTENDED); })); + + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("trgeometryFromBinary", {B}, T, TspatialFromWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("trgeometryFromEWKB", {B}, T, TspatialFromWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("trgeometryFromHexWKB", {V}, T, TspatialFromHexWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("trgeometryFromHexEWKB", {V}, T, TspatialFromHexWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("trgeometryFromText", {V}, T, TrgeometryFromTextExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("trgeometryFromEWKT", {V}, T, TrgeometryFromTextExec)); +} + + +void TRGeometryTypes::RegisterCastFunctions(ExtensionLoader &loader) { + loader.RegisterCastFunction( LogicalType::VARCHAR, TRGeometryTypes::TRGEOMETRY(), TrgeometryFunctions::StringToTrgeometry); + loader.RegisterCastFunction( TRGeometryTypes::TRGEOMETRY(), LogicalType::VARCHAR, TrgeometryFunctions::TrgeometryToString); +} + +} diff --git a/test/sql/trgeometry.test b/test/sql/trgeometry.test new file mode 100644 index 00000000..d1814eed --- /dev/null +++ b/test/sql/trgeometry.test @@ -0,0 +1,201 @@ +# name: test/sql/trgeometry.test +# description: Core trgeometry type port — construction, text/EWKT/MFJSON +# I/O and basic accessors. A trgeometry value is a moving +# rigid geometry: a reference geometry rigidly rotated and +# translated over time by an embedded temporal pose, written +# as 'Geometry;Pose@timestamp'. +# group: [sql] + +require mobilityduck + +# Test trgeometry constructor with parentheses (instant) +query I +SELECT asText(trgeometry('Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.5)@2000-01-01')); +---- +POLYGON((1 1,2 2,3 1,1 1));Pose(POINT(1 1),0.5)@2000-01-01 00:00:00+01 + +# Test trgeometry constructor without parentheses +query I +SELECT asText(trgeometry 'Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.5)@2000-01-01'); +---- +POLYGON((1 1,2 2,3 1,1 1));Pose(POINT(1 1),0.5)@2000-01-01 00:00:00+01 + +# Test asText with continuous sequence +query I +SELECT asText(trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02, Pose(Point(1 1), 0.5)@2000-01-03]'); +---- +POLYGON((1 1,2 2,3 1,1 1));[Pose(POINT(1 1),0.2)@2000-01-01 00:00:00+01, Pose(POINT(1 1),0.4)@2000-01-02 00:00:00+01, Pose(POINT(1 1),0.5)@2000-01-03 00:00:00+01] + +# Test asText with discrete sequence +query I +SELECT asText(trgeometry 'Polygon((1 1,2 2,3 1,1 1));{Pose(Point(1 1), 0.3)@2000-01-01, Pose(Point(1 1), 0.5)@2000-01-02}'); +---- +POLYGON((1 1,2 2,3 1,1 1));{Pose(POINT(1 1),0.3)@2000-01-01 00:00:00+01, Pose(POINT(1 1),0.5)@2000-01-02 00:00:00+01} + +# Test asEWKT is non-null +query I +SELECT asEWKT(trgeometry 'Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.5)@2000-01-01') IS NOT NULL; +---- +true + +# Test geometry/pose/timestamptz instant constructor round-trips +query I +SELECT trgeometry(geometry 'Polygon((1 1,2 2,3 1,1 1))', 'Pose(Point(1 1), 0.5)', timestamptz '2000-01-01') + = trgeometry 'Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.5)@2000-01-01'; +---- +true + +# Test geometry/tpose constructor builds a moving rigid geometry that +# round-trips against the canonical text form +query I +SELECT trgeometry(geometry 'Polygon((1 1,2 2,3 1,1 1))', + tpose '[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]') + = trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]'; +---- +true + +# Test the reference geometry accessor +query I +SELECT ST_AsText(geometry(trgeometry 'Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.5)@2000-01-01')); +---- +POLYGON ((1 1, 2 2, 3 1, 1 1)) + +# Test MFJSON round-trip is identity (format-agnostic) +query I +SELECT asText(trgeometryFromMFJSON(asMFJSON(trgeometry 'Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.5)@2000-01-01'))) + = asText(trgeometry 'Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.5)@2000-01-01'); +---- +true + +# Test MFJSON round-trip for a continuous sequence +query I +SELECT asText(trgeometryFromMFJSON(asMFJSON( + trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]'))) + = asText(trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]'); +---- +true + +# Test trgeometryFromText constructor +query I +SELECT asText(trgeometryFromText('Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.5)@2000-01-01')) IS NOT NULL; +---- +true + +# Test binary round-trip is identity +query I +SELECT asText(trgeometryFromBinary(asBinary(trgeometry 'Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.5)@2000-01-01'))) + = asText(trgeometry 'Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.5)@2000-01-01'); +---- +true + +# Test timeSpan function +query I +SELECT timeSpan(trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-03]'); +---- +[2000-01-01 00:00:00+01, 2000-01-03 00:00:00+01] + +# Test setInterp with discrete interpolation. A multi-instant continuous +# sequence cannot be discretized (it would drop the span semantics, MEOS +# errors), so lift an instant to a one-element discrete sequence. +query I +SELECT tempSubtype(setInterp(trgeometry 'Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.2)@2000-01-01', 'discrete')); +---- +Sequence + +# Test merge function +query I +SELECT numInstants(merge( + trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.3)@2000-01-02]', + trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.3)@2000-01-02, Pose(Point(1 1), 0.5)@2000-01-03]')); +---- +3 + +# Test tempSubtype with instant +query I +SELECT tempSubtype(trgeometry 'Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.5)@2000-01-01'); +---- +Instant + +# Test tempSubtype with discrete sequence +query I +SELECT tempSubtype(trgeometry 'Polygon((1 1,2 2,3 1,1 1));{Pose(Point(1 1), 0.3)@2000-01-01, Pose(Point(1 1), 0.5)@2000-01-02}'); +---- +Sequence + +# Test tempSubtype with continuous sequence +query I +SELECT tempSubtype(trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]'); +---- +Sequence + +# Test tempSubtype with sequence set +query I +SELECT tempSubtype(trgeometry 'Polygon((1 1,2 2,3 1,1 1));{[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02], [Pose(Point(2 2), 0.6)@2000-01-04, Pose(Point(2 2), 0.6)@2000-01-05]}'); +---- +SequenceSet + +# Test memSize is positive +query I +SELECT memSize(trgeometry 'Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.5)@2000-01-01') > 0; +---- +true + +# Test interp accessor +query I +SELECT interp(trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]'); +---- +Linear + +# Test getValue returns the pose value text +query I +SELECT getValue(trgeometry 'Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.5)@2000-01-01'); +---- +Pose(POINT(1 1),0.5) + +# Test startValue surfaces a non-null moved rigid-geometry snapshot +query I +SELECT startValue(trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]') IS NOT NULL; +---- +true + +# Test endValue surfaces a non-null moved rigid-geometry snapshot +query I +SELECT endValue(trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]') IS NOT NULL; +---- +true + +# Test startInstant +query I +SELECT asText(startInstant(trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]')); +---- +POLYGON((1 1,2 2,3 1,1 1));Pose(POINT(1 1),0.2)@2000-01-01 00:00:00+01 + +# Test endInstant +query I +SELECT asText(endInstant(trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]')); +---- +POLYGON((1 1,2 2,3 1,1 1));Pose(POINT(1 1),0.4)@2000-01-02 00:00:00+01 + +# Test instantN +query I +SELECT asText(instantN(trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02]', 1)); +---- +POLYGON((1 1,2 2,3 1,1 1));Pose(POINT(1 1),0.2)@2000-01-01 00:00:00+01 + +# Test getTimestamp function +query I +SELECT getTimestamp(trgeometry 'Polygon((1 1,2 2,3 1,1 1));Pose(Point(1 1), 0.5)@2023-01-01 10:00:00+00'); +---- +2023-01-01 11:00:00+01 + +# Test numInstants generic accessor +query I +SELECT numInstants(trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-02, Pose(Point(1 1), 0.5)@2000-01-03]'); +---- +3 + +# Test duration generic accessor +query I +SELECT duration(trgeometry 'Polygon((1 1,2 2,3 1,1 1));[Pose(Point(1 1), 0.2)@2000-01-01, Pose(Point(1 1), 0.4)@2000-01-03]'); +---- +2 days From 60855a476d4e65134496b10f69cfffad92c4e491 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Fri, 29 May 2026 17:05:50 +0200 Subject: [PATCH 6/6] Fix worker-thread and linkage crashes; complete extended-type MFJSON input Scalar and cast bodies run MEOS on DuckDB TaskScheduler worker threads, which need a per-thread meos_initialize(); a thread-local guard in the scalar exec wrapper and a cast trampoline (RegisterMeosCastFunction) cover every entry point, so timestamp formatting no longer dereferences a NULL session_timezone. Per-type DuckDB callbacks and blob helpers have internal linkage and a single canonical blob round-trip (TemporalToBlob / BlobToTemporal) declared once in temporal/temporal_blob.hpp, so each function-pointer registration binds to its own body. Tpoint_make_simple builds its list via UnifiedVectorFormat. Scalar results take their vector type from the executor. tcbuffer, tnpoint and trgeometry expose FromMFJSON: tcbuffer through tcbuffer_from_mfjson, tnpoint and trgeometry through temporal_from_mfjson with their temporal type. MEOS is built with the circular-buffer and network-point MF-JSON input/output. --- CMakeLists.txt | 1 + src/geo/stbox_functions.cpp | 222 +-------------- src/geo/tcbuffer.cpp | 110 ++------ src/geo/tcbuffer_in_out.cpp | 43 +-- src/geo/tgeogpoint.cpp | 106 ++------ src/geo/tgeogpoint_functions.cpp | 6 - src/geo/tgeogpoint_in_out.cpp | 20 +- src/geo/tgeogpoint_ops.cpp | 104 ++++--- src/geo/tgeography.cpp | 105 ++----- src/geo/tgeography_in_out.cpp | 40 +-- src/geo/tgeography_ops.cpp | 104 ++++--- src/geo/tgeometry.cpp | 105 ++----- src/geo/tgeometry_in_out.cpp | 40 +-- src/geo/tgeometry_ops.cpp | 104 ++++--- src/geo/tgeompoint.cpp | 16 +- src/geo/tgeompoint_functions.cpp | 361 ++++--------------------- src/geo/tnpoint.cpp | 105 ++----- src/geo/tnpoint_in_out.cpp | 48 +--- src/geo/tpose.cpp | 112 ++------ src/geo/tpose_in_out.cpp | 49 +--- src/include/temporal/temporal_blob.hpp | 18 ++ src/mobilityduck_extension.cpp | 6 +- src/rgeo/trgeometry.cpp | 107 ++------ src/rgeo/trgeometry_in_out.cpp | 57 ++-- src/single_tile_getters.cpp | 6 - src/temporal/span_functions.cpp | 135 --------- src/temporal/spanset_functions.cpp | 33 --- src/temporal/tbox_functions.cpp | 177 ------------ src/temporal/temporal.cpp | 2 +- src/temporal/temporal_aggregates.cpp | 12 +- src/temporal/temporal_blob.cpp | 26 ++ src/temporal/temporal_functions.cpp | 328 +--------------------- 32 files changed, 511 insertions(+), 2197 deletions(-) create mode 100644 src/include/temporal/temporal_blob.hpp create mode 100644 src/temporal/temporal_blob.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index b69b9eb0..83b195fb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -59,6 +59,7 @@ set(EXTENSION_SOURCES src/spatial_ref_sys_csv.inc src/mobilityduck_extension.cpp src/temporal/temporal.cpp + src/temporal/temporal_blob.cpp src/temporal/temporal_functions.cpp src/temporal/temporal_aggregates.cpp src/temporal/tbox.cpp diff --git a/src/geo/stbox_functions.cpp b/src/geo/stbox_functions.cpp index b5398f02..c661fd2d 100644 --- a/src/geo/stbox_functions.cpp +++ b/src/geo/stbox_functions.cpp @@ -1,4 +1,5 @@ #include "meos_wrapper_simple.hpp" +#include "temporal/temporal_blob.hpp" #include "common.hpp" #include "geo/stbox_functions.hpp" @@ -50,7 +51,7 @@ inline STBox *Stbox_geodetic_xy_copy(const STBox *box) { 0.0, 0.0, stbox_hast(box) ? &box->period : nullptr); } -inline void Stbox_normalize_geodetic_srid(STBox *box) { +static void Stbox_normalize_geodetic_srid(STBox *box) { if ((stbox_isgeodetic(box) || MEOS_FLAGS_GET_GEODETIC(box->flags)) && box->srid == 0) { box->srid = 4326; } @@ -62,7 +63,7 @@ inline void Stbox_normalize_geodetic_srid(STBox *box) { * In/out functions: VARCHAR <-> STBOX ****************************************************/ -inline void Stbox_in_common(Vector &source, Vector &result, idx_t count) { +static void Stbox_in_common(Vector &source, Vector &result, idx_t count) { UnaryExecutor::ExecuteWithNulls( source, result, count, [&](string_t input_string, ValidityMask &mask, idx_t idx) -> string_t { @@ -91,9 +92,6 @@ inline void Stbox_in_common(Vector &source, Vector &result, idx_t count) { return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } bool StboxFunctions::Stbox_in_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { @@ -135,9 +133,6 @@ bool StboxFunctions::Stbox_out(Vector &source, Vector &result, idx_t count, Cast return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return success; } @@ -182,9 +177,6 @@ void StboxFunctions::Stbox_from_wkb(DataChunk &args, ExpressionState &state, Vec return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_from_hexwkb(DataChunk &args, ExpressionState &state, Vector &result) { @@ -213,9 +205,6 @@ void StboxFunctions::Stbox_from_hexwkb(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_as_text(DataChunk &args, ExpressionState &state, Vector &result) { @@ -247,9 +236,6 @@ void StboxFunctions::Stbox_as_text(DataChunk &args, ExpressionState &state, Vect return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_as_wkb(DataChunk &args, ExpressionState &state, Vector &result) { @@ -282,9 +268,6 @@ void StboxFunctions::Stbox_as_wkb(DataChunk &args, ExpressionState &state, Vecto return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_as_hexwkb(DataChunk &args, ExpressionState &state, Vector &result) { @@ -317,9 +300,6 @@ void StboxFunctions::Stbox_as_hexwkb(DataChunk &args, ExpressionState &state, Ve return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -360,9 +340,6 @@ void StboxFunctions::Geo_timestamptz_to_stbox(DataChunk &args, ExpressionState & return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Geo_tstzspan_to_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -420,9 +397,6 @@ void StboxFunctions::Geo_tstzspan_to_stbox(DataChunk &args, ExpressionState &sta return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -462,9 +436,6 @@ void StboxFunctions::Geo_to_stbox_common(Vector &source, Vector &result, idx_t c return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Geo_to_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -515,9 +486,6 @@ bool StboxFunctions::Geo_to_stbox_cast(Vector &source, Vector &result, idx_t cou return stored_result; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } static void Timestamptz_to_stbox_common(Vector &source, Vector &result, idx_t count) { @@ -543,9 +511,6 @@ static void Timestamptz_to_stbox_common(Vector &source, Vector &result, idx_t co return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Timestamptz_to_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -594,9 +559,6 @@ static void Tstzset_to_stbox_common(Vector &source, Vector &result, idx_t count) return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Tstzset_to_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -645,9 +607,6 @@ static void Tstzspan_to_stbox_common(Vector &source, Vector &result, idx_t count return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Tstzspan_to_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -732,9 +691,6 @@ void StboxFunctions::Stbox_hasx(DataChunk &args, ExpressionState &state, Vector return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_hasz(DataChunk &args, ExpressionState &state, Vector &result) { @@ -758,9 +714,6 @@ void StboxFunctions::Stbox_hasz(DataChunk &args, ExpressionState &state, Vector return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_hast(DataChunk &args, ExpressionState &state, Vector &result) { @@ -807,9 +760,6 @@ void StboxFunctions::Stbox_isgeodetic(DataChunk &args, ExpressionState &state, V return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_xmin(DataChunk &args, ExpressionState &state, Vector &result) { @@ -838,9 +788,6 @@ void StboxFunctions::Stbox_xmin(DataChunk &args, ExpressionState &state, Vector return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_xmax(DataChunk &args, ExpressionState &state, Vector &result) { @@ -870,9 +817,6 @@ void StboxFunctions::Stbox_xmax(DataChunk &args, ExpressionState &state, Vector } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_ymin(DataChunk &args, ExpressionState &state, Vector &result) { @@ -901,9 +845,6 @@ void StboxFunctions::Stbox_ymin(DataChunk &args, ExpressionState &state, Vector return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_ymax(DataChunk &args, ExpressionState &state, Vector &result) { @@ -932,9 +873,6 @@ void StboxFunctions::Stbox_ymax(DataChunk &args, ExpressionState &state, Vector return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_zmin(DataChunk &args, ExpressionState &state, Vector &result) { @@ -963,9 +901,6 @@ void StboxFunctions::Stbox_zmin(DataChunk &args, ExpressionState &state, Vector return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_zmax(DataChunk &args, ExpressionState &state, Vector &result) { @@ -994,9 +929,6 @@ void StboxFunctions::Stbox_zmax(DataChunk &args, ExpressionState &state, Vector return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_tmin(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1026,9 +958,6 @@ void StboxFunctions::Stbox_tmin(DataChunk &args, ExpressionState &state, Vector return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_tmax(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1058,9 +987,6 @@ void StboxFunctions::Stbox_tmax(DataChunk &args, ExpressionState &state, Vector return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_tmin_inc(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1089,9 +1015,6 @@ void StboxFunctions::Stbox_tmin_inc(DataChunk &args, ExpressionState &state, Vec return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_tmax_inc(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1120,9 +1043,6 @@ void StboxFunctions::Stbox_tmax_inc(DataChunk &args, ExpressionState &state, Vec return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_area(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1158,9 +1078,6 @@ void StboxFunctions::Stbox_area(DataChunk &args, ExpressionState &state, Vector return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_volume(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1189,9 +1106,6 @@ void StboxFunctions::Stbox_volume(DataChunk &args, ExpressionState &state, Vecto return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -1228,9 +1142,6 @@ void StboxFunctions::Stbox_shift_time(DataChunk &args, ExpressionState &state, V return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_scale_time(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1264,9 +1175,6 @@ void StboxFunctions::Stbox_scale_time(DataChunk &args, ExpressionState &state, V return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_shift_scale_time(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1300,9 +1208,6 @@ void StboxFunctions::Stbox_shift_scale_time(DataChunk &args, ExpressionState &st return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_get_space(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1334,9 +1239,6 @@ void StboxFunctions::Stbox_get_space(DataChunk &args, ExpressionState &state, Ve return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_expand_time(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1370,9 +1272,6 @@ void StboxFunctions::Stbox_expand_time(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_expand_space(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1414,9 +1313,6 @@ void StboxFunctions::Stbox_expand_space(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -1468,9 +1364,6 @@ void StboxFunctions::Overlaps_stbox_stbox(DataChunk &args, ExpressionState &stat return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Contains_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1518,9 +1411,6 @@ void StboxFunctions::Contains_stbox_stbox(DataChunk &args, ExpressionState &stat return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Contained_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1568,9 +1458,6 @@ void StboxFunctions::Contained_stbox_stbox(DataChunk &args, ExpressionState &sta return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Same_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1618,9 +1505,6 @@ void StboxFunctions::Same_stbox_stbox(DataChunk &args, ExpressionState &state, V return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Adjacent_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1668,9 +1552,6 @@ void StboxFunctions::Adjacent_stbox_stbox(DataChunk &args, ExpressionState &stat return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Left_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1718,9 +1599,6 @@ void StboxFunctions::Left_stbox_stbox(DataChunk &args, ExpressionState &state, V return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Overleft_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1768,9 +1646,6 @@ void StboxFunctions::Overleft_stbox_stbox(DataChunk &args, ExpressionState &stat return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Right_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1818,9 +1693,6 @@ void StboxFunctions::Right_stbox_stbox(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Overright_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1868,9 +1740,6 @@ void StboxFunctions::Overright_stbox_stbox(DataChunk &args, ExpressionState &sta return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Below_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1918,9 +1787,6 @@ void StboxFunctions::Below_stbox_stbox(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Overbelow_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1968,9 +1834,6 @@ void StboxFunctions::Overbelow_stbox_stbox(DataChunk &args, ExpressionState &sta return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Above_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2018,9 +1881,6 @@ void StboxFunctions::Above_stbox_stbox(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Overabove_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2068,9 +1928,6 @@ void StboxFunctions::Overabove_stbox_stbox(DataChunk &args, ExpressionState &sta return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Before_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2118,9 +1975,6 @@ void StboxFunctions::Before_stbox_stbox(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Overbefore_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2168,9 +2022,6 @@ void StboxFunctions::Overbefore_stbox_stbox(DataChunk &args, ExpressionState &st return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::After_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2218,9 +2069,6 @@ void StboxFunctions::After_stbox_stbox(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Overafter_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2268,9 +2116,6 @@ void StboxFunctions::Overafter_stbox_stbox(DataChunk &args, ExpressionState &sta return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Front_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2318,9 +2163,6 @@ void StboxFunctions::Front_stbox_stbox(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Overfront_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2368,9 +2210,6 @@ void StboxFunctions::Overfront_stbox_stbox(DataChunk &args, ExpressionState &sta return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Back_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2418,9 +2257,6 @@ void StboxFunctions::Back_stbox_stbox(DataChunk &args, ExpressionState &state, V return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Overback_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2468,9 +2304,6 @@ void StboxFunctions::Overback_stbox_stbox(DataChunk &args, ExpressionState &stat return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Union_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2536,9 +2369,6 @@ void StboxFunctions::Union_stbox_stbox(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Intersection_stbox_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2604,9 +2434,6 @@ void StboxFunctions::Intersection_stbox_stbox(DataChunk &args, ExpressionState & return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // Comparison operators @@ -2637,9 +2464,6 @@ void StboxFunctions::Stbox_eq(DataChunk &args, ExpressionState &state, Vector &r return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_ne(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2669,9 +2493,6 @@ void StboxFunctions::Stbox_ne(DataChunk &args, ExpressionState &state, Vector &r return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_le(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2701,9 +2522,6 @@ void StboxFunctions::Stbox_le(DataChunk &args, ExpressionState &state, Vector &r return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_lt(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2733,9 +2551,6 @@ void StboxFunctions::Stbox_lt(DataChunk &args, ExpressionState &state, Vector &r return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_ge(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2765,9 +2580,6 @@ void StboxFunctions::Stbox_ge(DataChunk &args, ExpressionState &state, Vector &r return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_gt(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2797,9 +2609,6 @@ void StboxFunctions::Stbox_gt(DataChunk &args, ExpressionState &state, Vector &r return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void StboxFunctions::Stbox_cmp(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2829,9 +2638,6 @@ void StboxFunctions::Stbox_cmp(DataChunk &args, ExpressionState &state, Vector & return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -2854,12 +2660,6 @@ inline Temporal *BlobToTempTile(string_t b) { return reinterpret_cast(copy); } -inline Temporal *BlobToTemp(string_t b) { - size_t sz = b.GetSize(); - uint8_t *copy = (uint8_t *)malloc(sz); - memcpy(copy, b.GetData(), sz); - return reinterpret_cast(copy); -} string_t StboxToResultBlob(Vector &result, const STBox *box) { string_t blob(reinterpret_cast(box), sizeof(STBox)); @@ -2934,7 +2734,6 @@ void StboxFunctions::Stbox_space_tiles(DataChunk &args, ExpressionState &state, free(bounds); free(origin); EmitStboxList(result, row, list_entries, boxes, count, total); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void StboxFunctions::Stbox_time_tiles(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2968,7 +2767,6 @@ void StboxFunctions::Stbox_time_tiles(DataChunk &args, ExpressionState &state, V free(bounds); EmitStboxList(result, row, list_entries, boxes, count, total); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void StboxFunctions::Stbox_space_time_tiles(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3012,7 +2810,6 @@ void StboxFunctions::Stbox_space_time_tiles(DataChunk &args, ExpressionState &st free(bounds); free(origin); EmitStboxList(result, row, list_entries, boxes, count, total); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void StboxFunctions::Tgeo_space_boxes(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3049,7 +2846,6 @@ void StboxFunctions::Tgeo_space_boxes(DataChunk &args, ExpressionState &state, V free(temp); free(origin); EmitStboxList(result, row, list_entries, boxes, count, total); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void StboxFunctions::Tgeo_space_time_boxes(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3094,7 +2890,6 @@ void StboxFunctions::Tgeo_space_time_boxes(DataChunk &args, ExpressionState &sta free(temp); free(origin); EmitStboxList(result, row, list_entries, boxes, count, total); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void StboxFunctions::Stbox_get_space_tile(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3132,7 +2927,6 @@ void StboxFunctions::Stbox_get_space_tile(DataChunk &args, ExpressionState &stat out_data[row] = StboxToResultBlob(result, box); free(box); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void StboxFunctions::Stbox_get_time_tile(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3165,7 +2959,6 @@ void StboxFunctions::Stbox_get_time_tile(DataChunk &args, ExpressionState &state out_data[row] = StboxToResultBlob(result, box); free(box); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void StboxFunctions::Stbox_get_space_time_tile(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3214,7 +3007,6 @@ void StboxFunctions::Stbox_get_space_time_tile(DataChunk &args, ExpressionState out_data[row] = StboxToResultBlob(result, box); free(box); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } #define DEFINE_TSPATIAL_TOPO(OP, MEOS) \ @@ -3222,7 +3014,7 @@ void StboxFunctions::OP##_tspatial_stbox(DataChunk &args, ExpressionState &state BinaryExecutor::Execute( \ args.data[0], args.data[1], result, args.size(), \ [](string_t bt, string_t bs) -> bool { \ - Temporal *t = BlobToTemp(bt); \ + Temporal *t = BlobToTemporal(bt); \ STBox *s = BlobToStbox(bs); \ bool r = MEOS##_tspatial_stbox(t, s); \ free(t); free(s); \ @@ -3234,7 +3026,7 @@ void StboxFunctions::OP##_stbox_tspatial(DataChunk &args, ExpressionState &state args.data[0], args.data[1], result, args.size(), \ [](string_t bs, string_t bt) -> bool { \ STBox *s = BlobToStbox(bs); \ - Temporal *t = BlobToTemp(bt); \ + Temporal *t = BlobToTemporal(bt); \ bool r = MEOS##_stbox_tspatial(s, t); \ free(s); free(t); \ return r; \ @@ -3244,8 +3036,8 @@ void StboxFunctions::OP##_tspatial_tspatial(DataChunk &args, ExpressionState &st BinaryExecutor::Execute( \ args.data[0], args.data[1], result, args.size(), \ [](string_t b1, string_t b2) -> bool { \ - Temporal *t1 = BlobToTemp(b1); \ - Temporal *t2 = BlobToTemp(b2); \ + Temporal *t1 = BlobToTemporal(b1); \ + Temporal *t2 = BlobToTemporal(b2); \ bool r = MEOS##_tspatial_tspatial(t1, t2); \ free(t1); free(t2); \ return r; \ diff --git a/src/geo/tcbuffer.cpp b/src/geo/tcbuffer.cpp index fd893556..eafb2d20 100644 --- a/src/geo/tcbuffer.cpp +++ b/src/geo/tcbuffer.cpp @@ -36,7 +36,7 @@ LogicalType TCBufferTypes::TCBUFFER() { * Constructors */ -inline void Tcbuffer_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tcbuffer_constructor(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -69,12 +69,9 @@ inline void Tcbuffer_constructor(DataChunk &args, ExpressionState &state, Vector return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tcbufferinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tcbufferinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &value_vec = args.data[0]; auto &t_vec = args.data[1]; @@ -126,13 +123,10 @@ inline void Tcbufferinst_constructor(DataChunk &args, ExpressionState &state, Ve }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tcbuffer_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tcbuffer_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { const char* default_interp = "step"; auto count = args.size(); auto arg_count = args.ColumnCount(); @@ -197,9 +191,6 @@ inline void Tcbuffer_sequence_from_tstzspan(DataChunk &args, ExpressionState &st }); - if (count == 1){ - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } TInstant **temparr_extract_cb(Vector &tcbuffer_arr_vec, list_entry_t list_entry, int *count) { @@ -264,7 +255,7 @@ TInstant **temparr_extract_cb(Vector &tcbuffer_arr_vec, list_entry_t list_entry, return instants; } -inline void Tcbuffer_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tcbuffer_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { // Default values const char* default_interp = "step"; bool default_lower_inc = true; @@ -398,9 +389,6 @@ inline void Tcbuffer_sequence_constructor(DataChunk &args, ExpressionState &stat } } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -410,7 +398,7 @@ inline void Tcbuffer_sequence_constructor(DataChunk &args, ExpressionState &stat * Conversions */ -inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -451,16 +439,13 @@ inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* * Transformations */ -inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -500,13 +485,10 @@ inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; auto &interp_vec = args.data[1]; @@ -551,13 +533,10 @@ inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom1_vec = args.data[0]; auto &tgeom2_vec = args.data[1]; @@ -605,9 +584,6 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -615,7 +591,7 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu * Accessor Functions */ -inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -642,15 +618,12 @@ inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &re return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -679,12 +652,9 @@ inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &res return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -706,9 +676,6 @@ inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r return static_cast(mem_size); }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // ---- Circular-buffer value accessors ---- @@ -736,7 +703,7 @@ inline const Cbuffer *cbuffer_from_instant_value(const TInstant *inst) { // (geometry) definition for all of them and a generically-named tcbuffer // value accessor silently renders the cbuffer as a geometry ("Unknown // geometry type: 0"). Keep these names unique. -inline void Tcbuffer_get_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tcbuffer_get_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); UnaryExecutor::Execute( args.data[0], result, count, @@ -752,14 +719,11 @@ inline void Tcbuffer_get_value(DataChunk &args, ExpressionState &state, Vector & return out; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tcbuffer_start_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tcbuffer_start_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -786,13 +750,10 @@ inline void Tcbuffer_start_value(DataChunk &args, ExpressionState &state, Vector return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tcbuffer_end_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tcbuffer_end_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -819,12 +780,9 @@ inline void Tcbuffer_end_value(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tcbuffer_point(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tcbuffer_point(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -856,12 +814,9 @@ inline void Tcbuffer_point(DataChunk &args, ExpressionState &state, Vector &resu return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tcbuffer_radius(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tcbuffer_radius(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -882,13 +837,10 @@ inline void Tcbuffer_radius(DataChunk &args, ExpressionState &state, Vector &res return r; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -906,12 +858,9 @@ inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -929,12 +878,9 @@ inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -971,12 +917,9 @@ inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vect return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -1013,15 +956,12 @@ inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; auto &n_vec = args.data[1]; @@ -1058,13 +998,10 @@ inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -1102,9 +1039,6 @@ inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } diff --git a/src/geo/tcbuffer_in_out.cpp b/src/geo/tcbuffer_in_out.cpp index 4c243817..2af9502b 100644 --- a/src/geo/tcbuffer_in_out.cpp +++ b/src/geo/tcbuffer_in_out.cpp @@ -1,4 +1,5 @@ #include "geo/tcbuffer.hpp" +#include "temporal/temporal_blob.hpp" #include "duckdb/main/extension/extension_loader.hpp" #include "duckdb/common/extension_type_info.hpp" #include @@ -16,7 +17,7 @@ extern "C" { namespace duckdb { -inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -62,12 +63,9 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -115,9 +113,6 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -150,9 +145,6 @@ bool TcbufferFunctions::StringToTcbuffer(Vector &source, Vector &result, idx_t c return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -194,9 +186,6 @@ bool TcbufferFunctions::TcbufferToString(Vector &source, Vector &result, idx_t c return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -206,15 +195,8 @@ bool TcbufferFunctions::TcbufferToString(Vector &source, Vector &result, idx_t c // `tcbuffer_from_mfjson` and `tcbuffer_in` are per-type. The result is // stored as a raw blob, the same format every other temporal type uses. -inline string_t StoreTempAsBlob(Vector &result, Temporal *t) { - size_t sz = temporal_mem_size(t); - string_t stored = StringVector::AddStringOrBlob( - result, string_t(reinterpret_cast(t), sz)); - free(t); - return stored; -} -inline void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { @@ -226,11 +208,11 @@ inline void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &resu Temporal *t = temporal_from_wkb(wkb, input.GetSize()); free(wkb); if (!t) throw InvalidInputException("fromBinary: invalid MEOS-WKB"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } -inline void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { @@ -238,19 +220,19 @@ inline void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &r Temporal *t = temporal_from_hexwkb(hex.c_str()); if (!t) throw InvalidInputException( "fromHexWKB: invalid hex-encoded MEOS-WKB"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } template -inline void TspatialFromStringExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TspatialFromStringExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { std::string s(input.GetData(), input.GetSize()); Temporal *t = FN(s.c_str()); if (!t) throw InvalidInputException("from*: invalid input"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } @@ -283,6 +265,9 @@ void TCBufferTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ ScalarFunction("tcbufferFromHexWKB", {V}, T, TspatialFromHexWkbExec)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tcbufferFromHexEWKB", {V}, T, TspatialFromHexWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("tcbufferFromMFJSON", {V}, T, + TspatialFromStringExec<&tcbuffer_from_mfjson>)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tcbufferFromText", {V}, T, TspatialFromStringExec<&tcbuffer_in>)); @@ -293,8 +278,8 @@ void TCBufferTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ void TCBufferTypes::RegisterCastFunctions(ExtensionLoader &loader) { - loader.RegisterCastFunction( LogicalType::VARCHAR, TCBufferTypes::TCBUFFER(), TcbufferFunctions::StringToTcbuffer); - loader.RegisterCastFunction( TCBufferTypes::TCBUFFER(), LogicalType::VARCHAR, TcbufferFunctions::TcbufferToString); + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, TCBufferTypes::TCBUFFER(), TcbufferFunctions::StringToTcbuffer); + RegisterMeosCastFunction(loader, TCBufferTypes::TCBUFFER(), LogicalType::VARCHAR, TcbufferFunctions::TcbufferToString); } } diff --git a/src/geo/tgeogpoint.cpp b/src/geo/tgeogpoint.cpp index 692d0426..8d687359 100644 --- a/src/geo/tgeogpoint.cpp +++ b/src/geo/tgeogpoint.cpp @@ -1726,7 +1726,6 @@ void TgeogAsMfjsonExec(DataChunk &args, ExpressionState &state, Vector &result) out_data[row] = StringVector::AddString(result, json); free(json); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TgeogFromMfjsonExec(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1813,7 +1812,7 @@ LogicalType TGeogpointType::TGEOGPOINT() { * Constructors */ -inline void Tgeogpoint_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tgeogpoint_constructor(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -1846,12 +1845,9 @@ inline void Tgeogpoint_constructor(DataChunk &args, ExpressionState &state, Vect return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tgeogpointinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tgeogpointinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &value_vec = args.data[0]; auto &t_vec = args.data[1]; @@ -1901,13 +1897,10 @@ inline void Tgeogpointinst_constructor(DataChunk &args, ExpressionState &state, }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tgeogpoint_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tgeogpoint_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { const char* default_interp = "step"; auto count = args.size(); auto arg_count = args.ColumnCount(); @@ -1972,9 +1965,6 @@ inline void Tgeogpoint_sequence_from_tstzspan(DataChunk &args, ExpressionState & }); - if (count == 1){ - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } TInstant **temparr_extract_gp(Vector &tgeogpoint_arr_vec, list_entry_t list_entry, int *count) { @@ -2039,7 +2029,7 @@ TInstant **temparr_extract_gp(Vector &tgeogpoint_arr_vec, list_entry_t list_entr return instants; } -inline void Tgeogpoint_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tgeogpoint_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { // Default values const char* default_interp = "linear"; bool default_lower_inc = true; @@ -2173,9 +2163,6 @@ inline void Tgeogpoint_sequence_constructor(DataChunk &args, ExpressionState &st } } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -2185,7 +2172,7 @@ inline void Tgeogpoint_sequence_constructor(DataChunk &args, ExpressionState &st * Conversions */ -inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -2226,16 +2213,13 @@ inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* * Transformations */ -inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -2275,13 +2259,10 @@ inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; auto &interp_vec = args.data[1]; @@ -2326,13 +2307,10 @@ inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom1_vec = args.data[0]; auto &tgeom2_vec = args.data[1]; @@ -2380,9 +2358,6 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -2390,7 +2365,7 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu * Accessor Functions */ -inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -2417,15 +2392,12 @@ inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &re return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -2454,12 +2426,9 @@ inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &res return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -2481,12 +2450,9 @@ inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r return static_cast(mem_size); }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tinstant_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tinstant_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -2510,14 +2476,11 @@ inline void Tinstant_value(DataChunk &args, ExpressionState &state, Vector &resu return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_start_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_start_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -2540,13 +2503,10 @@ inline void Temporal_start_value(DataChunk &args, ExpressionState &state, Vector return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_end_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_end_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -2570,13 +2530,10 @@ inline void Temporal_end_value(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -2594,12 +2551,9 @@ inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -2617,12 +2571,9 @@ inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -2659,12 +2610,9 @@ inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vect return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -2701,15 +2649,12 @@ inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; auto &n_vec = args.data[1]; @@ -2746,13 +2691,10 @@ inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -2790,12 +2732,9 @@ inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector &result) { +static void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector &result) { const char* default_interp = "step"; auto count = args.size(); auto &tgeogpoint_vec = args.data[0]; @@ -2864,9 +2803,6 @@ inline void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } diff --git a/src/geo/tgeogpoint_functions.cpp b/src/geo/tgeogpoint_functions.cpp index 87ecac96..66dfa76c 100644 --- a/src/geo/tgeogpoint_functions.cpp +++ b/src/geo/tgeogpoint_functions.cpp @@ -44,9 +44,6 @@ bool TgeogpointFunctions::Tpoint_in(Vector &source, Vector &result, idx_t count, return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -89,9 +86,6 @@ void TgeogpointFunctions::Tpointinst_constructor(DataChunk &args, ExpressionStat free(ret_data); return stored_data; }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } } // namespace duckdb diff --git a/src/geo/tgeogpoint_in_out.cpp b/src/geo/tgeogpoint_in_out.cpp index bb3b1af4..af67d284 100644 --- a/src/geo/tgeogpoint_in_out.cpp +++ b/src/geo/tgeogpoint_in_out.cpp @@ -16,7 +16,7 @@ extern "C" { namespace duckdb { -inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -43,7 +43,7 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); } - char *str = tspatial_as_text(temp, 0); + char *str = tspatial_as_text(temp, 15); if (!str) { free(data_copy); @@ -60,12 +60,9 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -93,7 +90,7 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); } - char *ewkt = tspatial_as_ewkt(temp, 0); + char *ewkt = tspatial_as_ewkt(temp, 15); if (!ewkt) { free(data_copy); @@ -111,9 +108,6 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -146,9 +140,6 @@ bool TgeogpointFunctions::StringToTgeogpoint(Vector &source, Vector &result, idx return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -190,9 +181,6 @@ bool TgeogpointFunctions::TgeogpointToString(Vector &source, Vector &result, idx return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } diff --git a/src/geo/tgeogpoint_ops.cpp b/src/geo/tgeogpoint_ops.cpp index 73cf4566..ab46adb5 100644 --- a/src/geo/tgeogpoint_ops.cpp +++ b/src/geo/tgeogpoint_ops.cpp @@ -3,6 +3,7 @@ // purely registration-and-glue; the heavy lifting stays in libmeos. #include "meos_wrapper_simple.hpp" +#include "temporal/temporal_blob.hpp" #include "common.hpp" #include "geo/tgeogpoint.hpp" @@ -34,20 +35,14 @@ namespace { // Argument-decoding helpers // ==================================================================== -inline Temporal *DecodeTemporalCopy(string_t blob) { - size_t sz = blob.GetSize(); - Temporal *t = (Temporal *) malloc(sz); - memcpy(t, blob.GetData(), sz); - return t; -} -inline STBox *DecodeStboxCopy(string_t blob) { +static STBox *DecodeStboxCopy(string_t blob) { STBox *b = (STBox *) malloc(sizeof(STBox)); memcpy(b, blob.GetData(), sizeof(STBox)); return b; } -inline Span *DecodeSpanCopy(string_t blob) { +static Span *DecodeSpanCopy(string_t blob) { Span *s = (Span *) malloc(sizeof(Span)); memcpy(s, blob.GetData(), sizeof(Span)); return s; @@ -62,7 +57,7 @@ void TspatialStboxBoolExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t b_blob) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); STBox *b = DecodeStboxCopy(b_blob); bool r = FN(t, b); free(t); free(b); @@ -81,7 +76,7 @@ void StboxTspatialBoolExec(DataChunk &args, ExpressionState &, Vector &result) { args.data[0], args.data[1], result, args.size(), [&](string_t b_blob, string_t t_blob) { STBox *b = DecodeStboxCopy(b_blob); - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); bool r = FN(t, b); free(t); free(b); return r; @@ -93,8 +88,8 @@ void TspatialTspatialBoolExec(DataChunk &args, ExpressionState &, Vector &result BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b) { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); bool r = FN(t1, t2); free(t1); free(t2); return r; @@ -106,7 +101,7 @@ void TemporalTstzspanBoolExec(DataChunk &args, ExpressionState &, Vector &result BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t s_blob) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); Span *s = DecodeSpanCopy(s_blob); bool r = FN(t, s); free(t); free(s); @@ -120,7 +115,7 @@ void TstzspanTemporalBoolExec(DataChunk &args, ExpressionState &, Vector &result args.data[0], args.data[1], result, args.size(), [&](string_t s_blob, string_t t_blob) { Span *s = DecodeSpanCopy(s_blob); - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); bool r = FN(s, t); free(t); free(s); return r; @@ -137,7 +132,7 @@ void TgeoGeoIntExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t g_blob, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(t, gs); @@ -152,7 +147,7 @@ void GeoTgeoIntExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t g_blob, string_t t_blob, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(gs, t); @@ -167,8 +162,8 @@ void TgeoTgeoIntExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); int r = FN(t1, t2); free(t1); free(t2); if (r < 0) { mask.SetInvalid(idx); return false; } @@ -181,7 +176,7 @@ void TgeoGeoDistIntExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t t_blob, string_t g_blob, double dist, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(t, gs, dist); @@ -196,7 +191,7 @@ void GeoTgeoDistIntExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t g_blob, string_t t_blob, double dist, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(gs, t, dist); @@ -213,7 +208,7 @@ void GeoTgeoDistIntExec_FromTgeoGeo(DataChunk &args, ExpressionState &, Vector & TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t g_blob, string_t t_blob, double dist, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(t, gs, dist); @@ -228,8 +223,8 @@ void TgeoTgeoDistIntExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t a, string_t b, double dist, ValidityMask &mask, idx_t idx) { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); int r = FN(t1, t2, dist); free(t1); free(t2); if (r < 0) { mask.SetInvalid(idx); return false; } @@ -243,20 +238,13 @@ void TgeoTgeoDistIntExec(DataChunk &args, ExpressionState &, Vector &result) { // covering the whole input duration. // ==================================================================== -inline string_t TemporalToBlob(Vector &result, Temporal *t) { - size_t sz = temporal_mem_size(t); - string_t out = StringVector::AddStringOrBlob( - result, reinterpret_cast(t), sz); - free(t); - return out; -} template void TgeoGeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t g_blob, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(t, gs); @@ -271,7 +259,7 @@ void GeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t g_blob, string_t t_blob, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(gs, t); @@ -286,8 +274,8 @@ void TgeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); Temporal *r = FN(t1, t2); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } @@ -301,7 +289,7 @@ void TgeoGeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t t_blob, string_t g_blob, double dist, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(t, gs, dist); @@ -316,7 +304,7 @@ void GeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t g_blob, string_t t_blob, double dist, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(gs, t, dist); @@ -331,8 +319,8 @@ void TgeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t a, string_t b, double dist, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); Temporal *r = FN(t1, t2, dist); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } @@ -349,7 +337,7 @@ void TgeoGeoDistanceExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t g_blob, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(t, gs); @@ -364,8 +352,8 @@ void TgeoTgeoDistanceExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); Temporal *r = FN(t1, t2); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } @@ -379,14 +367,14 @@ void TgeoTgeoDistanceExec(DataChunk &args, ExpressionState &, Vector &result) { // tgeogpoint <-> tgeography coercions. // ==================================================================== -inline string_t StboxToBlob(Vector &result, STBox *box) { +static string_t StboxToBlob(Vector &result, STBox *box) { string_t out = StringVector::AddStringOrBlob( result, reinterpret_cast(box), sizeof(STBox)); free(box); return out; } -inline string_t GeoToBlobAsHex(Vector &result, GSERIALIZED *gs) { +static string_t GeoToBlobAsHex(Vector &result, GSERIALIZED *gs) { if (!gs) return string_t(); size_t sz = 0; uint8_t *ewkb = geo_as_ewkb(gs, NULL, &sz); @@ -401,7 +389,7 @@ void TspatialSridExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); int32_t srid = tspatial_srid(t); free(t); return srid; @@ -412,7 +400,7 @@ void TspatialSetSridExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t blob, int32_t srid) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tspatial_set_srid(t, srid); free(t); if (!r) throw InvalidInputException("setSRID failed"); @@ -424,7 +412,7 @@ void TspatialTransformExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t blob, int32_t srid) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tspatial_transform(t, srid); free(t); if (!r) throw InvalidInputException("transform failed"); @@ -436,7 +424,7 @@ void TspatialToStboxExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); STBox *box = tspatial_to_stbox(t); free(t); return StboxToBlob(result, box); @@ -449,7 +437,7 @@ void TgeogpointToTgeographyExec(DataChunk &args, ExpressionState &, Vector &resu UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tgeogpoint_to_tgeography(t); free(t); if (!r) throw InvalidInputException("tgeography(tgeogpoint) failed"); @@ -461,7 +449,7 @@ void TgeographyToTgeogpointExec(DataChunk &args, ExpressionState &, Vector &resu UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tgeography_to_tgeogpoint(t); free(t); if (!r) throw InvalidInputException("tgeogpoint(tgeography) failed"); @@ -473,7 +461,7 @@ void TgeoCentroidExec(DataChunk &args, ExpressionState &state, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) -> string_t { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tgeo_centroid(t); free(t); if (!r) throw InvalidInputException("centroid failed"); @@ -485,7 +473,7 @@ void TgeoConvexHullExec(DataChunk &args, ExpressionState &state, Vector &result) UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) -> string_t { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); GSERIALIZED *gs = tgeo_convex_hull(t); free(t); return GeoToBlobAsHex(result, gs); @@ -498,7 +486,7 @@ void TgeoTraversedAreaExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::Execute( args.data[0], args.data[1], result, cnt, [&](string_t blob, bool unary_union) -> string_t { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); GSERIALIZED *gs = tgeo_traversed_area(t, unary_union); free(t); return GeoToBlobAsHex(result, gs); @@ -507,7 +495,7 @@ void TgeoTraversedAreaExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, cnt, [&](string_t blob) -> string_t { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); GSERIALIZED *gs = tgeo_traversed_area(t, false); free(t); return GeoToBlobAsHex(result, gs); @@ -836,7 +824,7 @@ void TGeogpointOps::RegisterScalarFunctions(ExtensionLoader &loader) { result_validity.SetInvalid(i); continue; } - Temporal *t = DecodeTemporalCopy(t_data[i]); + Temporal *t = BlobToTemporal(t_data[i]); GSERIALIZED *origin = geompoint_make3dz(0, 0.0, 0.0, 0.0); int count = 0; STBox *boxes = tgeo_space_boxes( @@ -876,7 +864,7 @@ void TGeogpointOps::RegisterScalarFunctions(ExtensionLoader &loader) { result_validity.SetInvalid(i); continue; } - Temporal *t = DecodeTemporalCopy(t_data[i]); + Temporal *t = BlobToTemporal(t_data[i]); GSERIALIZED *origin = geompoint_make3dz(0, 0.0, 0.0, 0.0); MeosInterval iv = IntervaltToInterval(dur_data[i]); constexpr int64_t DEFAULT_TIME_ORIGIN_MEOS = 2LL * 86400LL * 1000000LL; @@ -906,7 +894,7 @@ void TGeogpointOps::RegisterScalarFunctions(ExtensionLoader &loader) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t blob, double eps) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = FN(t, eps); free(t); if (!r) throw InvalidInputException("simplify failed"); @@ -930,7 +918,7 @@ void TGeogpointOps::RegisterScalarFunctions(ExtensionLoader &loader) { continue; } bool sync = has_third ? FlatVector::GetData(args.data[2])[i] : true; - Temporal *t = DecodeTemporalCopy(blob_data[i]); + Temporal *t = BlobToTemporal(blob_data[i]); Temporal *r = FN(t, eps_data[i], sync); free(t); if (!r) { @@ -952,7 +940,7 @@ void TGeogpointOps::RegisterScalarFunctions(ExtensionLoader &loader) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t blob, interval_t iv) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); MeosInterval miv = IntervaltToInterval(iv); Temporal *r = temporal_simplify_min_tdelta(t, &miv); free(t); diff --git a/src/geo/tgeography.cpp b/src/geo/tgeography.cpp index 64c064b0..e9e3f73a 100644 --- a/src/geo/tgeography.cpp +++ b/src/geo/tgeography.cpp @@ -34,7 +34,7 @@ LogicalType TGeographyTypes::TGEOGRAPHY() { * Constructors */ -inline void Tgeog_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tgeog_constructor(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -67,12 +67,9 @@ inline void Tgeog_constructor(DataChunk &args, ExpressionState &state, Vector &r return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tgeoginst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tgeoginst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &value_vec = args.data[0]; auto &t_vec = args.data[1]; @@ -116,13 +113,10 @@ inline void Tgeoginst_constructor(DataChunk &args, ExpressionState &state, Vecto }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tgeography_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tgeography_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { const char* default_interp = "step"; auto count = args.size(); auto arg_count = args.ColumnCount(); @@ -187,9 +181,6 @@ inline void Tgeography_sequence_from_tstzspan(DataChunk &args, ExpressionState & }); - if (count == 1){ - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } TInstant **temparr_extract_g(Vector &tgeography_arr_vec, list_entry_t list_entry, int *count) { @@ -254,7 +245,7 @@ TInstant **temparr_extract_g(Vector &tgeography_arr_vec, list_entry_t list_entry return instants; } -inline void Tgeography_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tgeography_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { // Default values const char* default_interp = "step"; bool default_lower_inc = true; @@ -388,9 +379,6 @@ inline void Tgeography_sequence_constructor(DataChunk &args, ExpressionState &st } } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -400,7 +388,7 @@ inline void Tgeography_sequence_constructor(DataChunk &args, ExpressionState &st * Conversions */ -inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -441,16 +429,13 @@ inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* * Transformations */ -inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -490,13 +475,10 @@ inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; auto &interp_vec = args.data[1]; @@ -541,13 +523,10 @@ inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom1_vec = args.data[0]; auto &tgeom2_vec = args.data[1]; @@ -595,9 +574,6 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -605,7 +581,7 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu * Accessor Functions */ -inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -632,15 +608,12 @@ inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &re return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -669,12 +642,9 @@ inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &res return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -696,12 +666,9 @@ inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r return static_cast(mem_size); }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tinstant_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tinstant_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -725,14 +692,11 @@ inline void Tinstant_value(DataChunk &args, ExpressionState &state, Vector &resu return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_start_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_start_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -755,13 +719,10 @@ inline void Temporal_start_value(DataChunk &args, ExpressionState &state, Vector return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_end_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_end_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -785,13 +746,10 @@ inline void Temporal_end_value(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -809,12 +767,9 @@ inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -832,12 +787,9 @@ inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -874,12 +826,9 @@ inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vect return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -916,15 +865,12 @@ inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; auto &n_vec = args.data[1]; @@ -961,13 +907,10 @@ inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -1005,12 +948,9 @@ inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector &result) { +static void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector &result) { const char* default_interp = "step"; auto count = args.size(); auto &tgeography_vec = args.data[0]; @@ -1079,9 +1019,6 @@ inline void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } diff --git a/src/geo/tgeography_in_out.cpp b/src/geo/tgeography_in_out.cpp index 2920f3a7..1efd5dca 100644 --- a/src/geo/tgeography_in_out.cpp +++ b/src/geo/tgeography_in_out.cpp @@ -1,4 +1,5 @@ #include "geo/tgeography.hpp" +#include "temporal/temporal_blob.hpp" #include "duckdb/main/extension/extension_loader.hpp" #include "duckdb/common/extension_type_info.hpp" #include @@ -15,7 +16,7 @@ extern "C" { namespace duckdb { -inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -42,7 +43,7 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); } - char *str = tspatial_as_text(temp, 0); + char *str = tspatial_as_text(temp, 15); if (!str) { free(data_copy); @@ -59,12 +60,9 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -92,7 +90,7 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); } - char *ewkt = tspatial_as_ewkt(temp, 0); + char *ewkt = tspatial_as_ewkt(temp, 15); if (!ewkt) { free(data_copy); @@ -110,9 +108,6 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -145,9 +140,6 @@ bool TgeographyFunctions::StringToTgeography(Vector &source, Vector &result, idx return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -189,9 +181,6 @@ bool TgeographyFunctions::TgeographyToString(Vector &source, Vector &result, idx return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -199,15 +188,8 @@ bool TgeographyFunctions::TgeographyToString(Vector &source, Vector &result, idx // Mirror of the helpers in tgeometry_in_out.cpp; per-type for MFJSON / // text since MEOS uses tgeography_from_mfjson / tgeography_in there. -inline string_t StoreTempAsBlobGeog(Vector &result, Temporal *t) { - size_t sz = temporal_mem_size(t); - string_t stored = StringVector::AddStringOrBlob( - result, string_t(reinterpret_cast(t), sz)); - free(t); - return stored; -} -inline void TgeographyFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TgeographyFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { @@ -219,11 +201,11 @@ inline void TgeographyFromWkbExec(DataChunk &args, ExpressionState &, Vector &re Temporal *t = temporal_from_wkb(wkb, input.GetSize()); free(wkb); if (!t) throw InvalidInputException("fromBinary: invalid MEOS-WKB"); - return StoreTempAsBlobGeog(result, t); + return TemporalToBlob(result, t); }); } -inline void TgeographyFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TgeographyFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { @@ -231,19 +213,19 @@ inline void TgeographyFromHexWkbExec(DataChunk &args, ExpressionState &, Vector Temporal *t = temporal_from_hexwkb(hex.c_str()); if (!t) throw InvalidInputException( "fromHexWKB: invalid hex-encoded MEOS-WKB"); - return StoreTempAsBlobGeog(result, t); + return TemporalToBlob(result, t); }); } template -inline void TgeographyFromStringExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TgeographyFromStringExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { std::string s(input.GetData(), input.GetSize()); Temporal *t = FN(s.c_str()); if (!t) throw InvalidInputException("from*: invalid input"); - return StoreTempAsBlobGeog(result, t); + return TemporalToBlob(result, t); }); } diff --git a/src/geo/tgeography_ops.cpp b/src/geo/tgeography_ops.cpp index af2dac14..321c3bb1 100644 --- a/src/geo/tgeography_ops.cpp +++ b/src/geo/tgeography_ops.cpp @@ -3,6 +3,7 @@ // purely registration-and-glue; the heavy lifting stays in libmeos. #include "meos_wrapper_simple.hpp" +#include "temporal/temporal_blob.hpp" #include "common.hpp" #include "geo/tgeography.hpp" @@ -35,20 +36,14 @@ namespace { // Argument-decoding helpers // ==================================================================== -inline Temporal *DecodeTemporalCopy(string_t blob) { - size_t sz = blob.GetSize(); - Temporal *t = (Temporal *) malloc(sz); - memcpy(t, blob.GetData(), sz); - return t; -} -inline STBox *DecodeStboxCopy(string_t blob) { +static STBox *DecodeStboxCopy(string_t blob) { STBox *b = (STBox *) malloc(sizeof(STBox)); memcpy(b, blob.GetData(), sizeof(STBox)); return b; } -inline Span *DecodeSpanCopy(string_t blob) { +static Span *DecodeSpanCopy(string_t blob) { Span *s = (Span *) malloc(sizeof(Span)); memcpy(s, blob.GetData(), sizeof(Span)); return s; @@ -63,7 +58,7 @@ void TspatialStboxBoolExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t b_blob) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); STBox *b = DecodeStboxCopy(b_blob); bool r = FN(t, b); free(t); free(b); @@ -82,7 +77,7 @@ void StboxTspatialBoolExec(DataChunk &args, ExpressionState &, Vector &result) { args.data[0], args.data[1], result, args.size(), [&](string_t b_blob, string_t t_blob) { STBox *b = DecodeStboxCopy(b_blob); - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); bool r = FN(t, b); free(t); free(b); return r; @@ -94,8 +89,8 @@ void TspatialTspatialBoolExec(DataChunk &args, ExpressionState &, Vector &result BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b) { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); bool r = FN(t1, t2); free(t1); free(t2); return r; @@ -107,7 +102,7 @@ void TemporalTstzspanBoolExec(DataChunk &args, ExpressionState &, Vector &result BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t s_blob) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); Span *s = DecodeSpanCopy(s_blob); bool r = FN(t, s); free(t); free(s); @@ -121,7 +116,7 @@ void TstzspanTemporalBoolExec(DataChunk &args, ExpressionState &, Vector &result args.data[0], args.data[1], result, args.size(), [&](string_t s_blob, string_t t_blob) { Span *s = DecodeSpanCopy(s_blob); - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); bool r = FN(s, t); free(t); free(s); return r; @@ -138,7 +133,7 @@ void TgeoGeoIntExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t g_blob, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(t, gs); @@ -153,7 +148,7 @@ void GeoTgeoIntExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t g_blob, string_t t_blob, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(gs, t); @@ -168,8 +163,8 @@ void TgeoTgeoIntExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); int r = FN(t1, t2); free(t1); free(t2); if (r < 0) { mask.SetInvalid(idx); return false; } @@ -182,7 +177,7 @@ void TgeoGeoDistIntExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t t_blob, string_t g_blob, double dist, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(t, gs, dist); @@ -197,7 +192,7 @@ void GeoTgeoDistIntExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t g_blob, string_t t_blob, double dist, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(gs, t, dist); @@ -214,7 +209,7 @@ void GeoTgeoDistIntExec_FromTgeoGeo(DataChunk &args, ExpressionState &, Vector & TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t g_blob, string_t t_blob, double dist, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(t, gs, dist); @@ -229,8 +224,8 @@ void TgeoTgeoDistIntExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t a, string_t b, double dist, ValidityMask &mask, idx_t idx) { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); int r = FN(t1, t2, dist); free(t1); free(t2); if (r < 0) { mask.SetInvalid(idx); return false; } @@ -244,20 +239,13 @@ void TgeoTgeoDistIntExec(DataChunk &args, ExpressionState &, Vector &result) { // covering the whole input duration. // ==================================================================== -inline string_t TemporalToBlob(Vector &result, Temporal *t) { - size_t sz = temporal_mem_size(t); - string_t out = StringVector::AddStringOrBlob( - result, reinterpret_cast(t), sz); - free(t); - return out; -} template void TgeoGeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t g_blob, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(t, gs); @@ -272,7 +260,7 @@ void GeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t g_blob, string_t t_blob, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(gs, t); @@ -287,8 +275,8 @@ void TgeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); Temporal *r = FN(t1, t2); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } @@ -302,7 +290,7 @@ void TgeoGeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t t_blob, string_t g_blob, double dist, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(t, gs, dist); @@ -317,7 +305,7 @@ void GeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t g_blob, string_t t_blob, double dist, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(gs, t, dist); @@ -332,8 +320,8 @@ void TgeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t a, string_t b, double dist, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); Temporal *r = FN(t1, t2, dist); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } @@ -350,7 +338,7 @@ void TgeoGeoDistanceExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t g_blob, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(t, gs); @@ -365,8 +353,8 @@ void TgeoTgeoDistanceExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); Temporal *r = FN(t1, t2); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } @@ -380,14 +368,14 @@ void TgeoTgeoDistanceExec(DataChunk &args, ExpressionState &, Vector &result) { // tgeography <-> tgeogpoint coercions. // ==================================================================== -inline string_t StboxToBlob(Vector &result, STBox *box) { +static string_t StboxToBlob(Vector &result, STBox *box) { string_t out = StringVector::AddStringOrBlob( result, reinterpret_cast(box), sizeof(STBox)); free(box); return out; } -inline string_t GeoToBlobAsHex(Vector &result, GSERIALIZED *gs) { +static string_t GeoToBlobAsHex(Vector &result, GSERIALIZED *gs) { if (!gs) return string_t(); size_t sz = 0; uint8_t *ewkb = geo_as_ewkb(gs, NULL, &sz); @@ -402,7 +390,7 @@ void TspatialSridExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); int32_t srid = tspatial_srid(t); free(t); return srid; @@ -413,7 +401,7 @@ void TspatialSetSridExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t blob, int32_t srid) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tspatial_set_srid(t, srid); free(t); if (!r) throw InvalidInputException("setSRID failed"); @@ -425,7 +413,7 @@ void TspatialTransformExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t blob, int32_t srid) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tspatial_transform(t, srid); free(t); if (!r) throw InvalidInputException("transform failed"); @@ -437,7 +425,7 @@ void TspatialToStboxExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); STBox *box = tspatial_to_stbox(t); free(t); return StboxToBlob(result, box); @@ -451,7 +439,7 @@ void TgeographyToTgeometryExec(DataChunk &args, ExpressionState &, Vector &resul UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tgeography_to_tgeometry(t); free(t); if (!r) throw InvalidInputException("tgeometry(tgeography) failed"); @@ -463,7 +451,7 @@ void TgeometryToTgeographyExec(DataChunk &args, ExpressionState &, Vector &resul UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tgeometry_to_tgeography(t); free(t); if (!r) throw InvalidInputException("tgeography(tgeometry) failed"); @@ -475,7 +463,7 @@ void TgeoCentroidExec(DataChunk &args, ExpressionState &state, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) -> string_t { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tgeo_centroid(t); free(t); if (!r) throw InvalidInputException("centroid failed"); @@ -487,7 +475,7 @@ void TgeoConvexHullExec(DataChunk &args, ExpressionState &state, Vector &result) UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) -> string_t { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); GSERIALIZED *gs = tgeo_convex_hull(t); free(t); return GeoToBlobAsHex(result, gs); @@ -500,7 +488,7 @@ void TgeoTraversedAreaExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::Execute( args.data[0], args.data[1], result, cnt, [&](string_t blob, bool unary_union) -> string_t { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); GSERIALIZED *gs = tgeo_traversed_area(t, unary_union); free(t); return GeoToBlobAsHex(result, gs); @@ -509,7 +497,7 @@ void TgeoTraversedAreaExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, cnt, [&](string_t blob) -> string_t { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); GSERIALIZED *gs = tgeo_traversed_area(t, false); free(t); return GeoToBlobAsHex(result, gs); @@ -839,7 +827,7 @@ void TGeographyOps::RegisterScalarFunctions(ExtensionLoader &loader) { result_validity.SetInvalid(i); continue; } - Temporal *t = DecodeTemporalCopy(t_data[i]); + Temporal *t = BlobToTemporal(t_data[i]); GSERIALIZED *origin = geompoint_make3dz(0, 0.0, 0.0, 0.0); int count = 0; STBox *boxes = tgeo_space_boxes( @@ -879,7 +867,7 @@ void TGeographyOps::RegisterScalarFunctions(ExtensionLoader &loader) { result_validity.SetInvalid(i); continue; } - Temporal *t = DecodeTemporalCopy(t_data[i]); + Temporal *t = BlobToTemporal(t_data[i]); GSERIALIZED *origin = geompoint_make3dz(0, 0.0, 0.0, 0.0); MeosInterval iv = IntervaltToInterval(dur_data[i]); constexpr int64_t DEFAULT_TIME_ORIGIN_MEOS = 2LL * 86400LL * 1000000LL; @@ -909,7 +897,7 @@ void TGeographyOps::RegisterScalarFunctions(ExtensionLoader &loader) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t blob, double eps) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = FN(t, eps); free(t); if (!r) throw InvalidInputException("simplify failed"); @@ -933,7 +921,7 @@ void TGeographyOps::RegisterScalarFunctions(ExtensionLoader &loader) { continue; } bool sync = has_third ? FlatVector::GetData(args.data[2])[i] : true; - Temporal *t = DecodeTemporalCopy(blob_data[i]); + Temporal *t = BlobToTemporal(blob_data[i]); Temporal *r = FN(t, eps_data[i], sync); free(t); if (!r) { @@ -955,7 +943,7 @@ void TGeographyOps::RegisterScalarFunctions(ExtensionLoader &loader) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t blob, interval_t iv) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); MeosInterval miv = IntervaltToInterval(iv); Temporal *r = temporal_simplify_min_tdelta(t, &miv); free(t); diff --git a/src/geo/tgeometry.cpp b/src/geo/tgeometry.cpp index d95683b1..2076acb6 100644 --- a/src/geo/tgeometry.cpp +++ b/src/geo/tgeometry.cpp @@ -35,7 +35,7 @@ LogicalType TGeometryTypes::TGEOMETRY() { * Constructors */ -inline void Tgeo_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tgeo_constructor(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -68,12 +68,9 @@ inline void Tgeo_constructor(DataChunk &args, ExpressionState &state, Vector &re return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tgeoinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tgeoinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &value_vec = args.data[0]; auto &t_vec = args.data[1]; @@ -117,13 +114,10 @@ inline void Tgeoinst_constructor(DataChunk &args, ExpressionState &state, Vector }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tgeometry_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tgeometry_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { const char* default_interp = "step"; auto count = args.size(); auto arg_count = args.ColumnCount(); @@ -188,9 +182,6 @@ inline void Tgeometry_sequence_from_tstzspan(DataChunk &args, ExpressionState &s }); - if (count == 1){ - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } TInstant **temparr_extract(Vector &tgeometry_arr_vec, list_entry_t list_entry, int *count) { @@ -255,7 +246,7 @@ TInstant **temparr_extract(Vector &tgeometry_arr_vec, list_entry_t list_entry, i return instants; } -inline void Tgeometry_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tgeometry_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { // Default values const char* default_interp = "step"; bool default_lower_inc = true; @@ -389,9 +380,6 @@ inline void Tgeometry_sequence_constructor(DataChunk &args, ExpressionState &sta } } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -401,7 +389,7 @@ inline void Tgeometry_sequence_constructor(DataChunk &args, ExpressionState &sta * Conversions */ -inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -442,16 +430,13 @@ inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* * Transformations */ -inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -491,13 +476,10 @@ inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; auto &interp_vec = args.data[1]; @@ -542,13 +524,10 @@ inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom1_vec = args.data[0]; auto &tgeom2_vec = args.data[1]; @@ -596,9 +575,6 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -606,7 +582,7 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu * Accessor Functions */ -inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -633,15 +609,12 @@ inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &re return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -670,12 +643,9 @@ inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &res return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -697,12 +667,9 @@ inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r return static_cast(mem_size); }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tinstant_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tinstant_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -726,14 +693,11 @@ inline void Tinstant_value(DataChunk &args, ExpressionState &state, Vector &resu return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_start_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_start_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -756,13 +720,10 @@ inline void Temporal_start_value(DataChunk &args, ExpressionState &state, Vector return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_end_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_end_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -786,13 +747,10 @@ inline void Temporal_end_value(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -810,12 +768,9 @@ inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -833,12 +788,9 @@ inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -875,12 +827,9 @@ inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vect return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -917,15 +866,12 @@ inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; auto &n_vec = args.data[1]; @@ -962,13 +908,10 @@ inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -1006,12 +949,9 @@ inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector &result) { +static void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector &result) { const char* default_interp = "step"; auto count = args.size(); auto &tgeometry_vec = args.data[0]; @@ -1080,9 +1020,6 @@ inline void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } diff --git a/src/geo/tgeometry_in_out.cpp b/src/geo/tgeometry_in_out.cpp index 7733b4e9..41b37ae2 100644 --- a/src/geo/tgeometry_in_out.cpp +++ b/src/geo/tgeometry_in_out.cpp @@ -1,4 +1,5 @@ #include "geo/tgeometry.hpp" +#include "temporal/temporal_blob.hpp" #include "duckdb/main/extension/extension_loader.hpp" #include "duckdb/common/extension_type_info.hpp" #include @@ -15,7 +16,7 @@ extern "C" { namespace duckdb { -inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -42,7 +43,7 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); } - char *str = tspatial_as_text(temp, 0); + char *str = tspatial_as_text(temp, 15); if (!str) { free(data_copy); @@ -59,12 +60,9 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -92,7 +90,7 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); } - char *ewkt = tspatial_as_ewkt(temp, 0); + char *ewkt = tspatial_as_ewkt(temp, 15); if (!ewkt) { free(data_copy); @@ -110,9 +108,6 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -145,9 +140,6 @@ bool TgeometryFunctions::StringToTgeometry(Vector &source, Vector &result, idx_t return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -189,9 +181,6 @@ bool TgeometryFunctions::TgeometryToString(Vector &source, Vector &result, idx_t return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -202,15 +191,8 @@ bool TgeometryFunctions::TgeometryToString(Vector &source, Vector &result, idx_t // `tgeography_in` are per-type. The result is stored as a raw blob, the // same format every other temporal type uses. -inline string_t StoreTempAsBlob(Vector &result, Temporal *t) { - size_t sz = temporal_mem_size(t); - string_t stored = StringVector::AddStringOrBlob( - result, string_t(reinterpret_cast(t), sz)); - free(t); - return stored; -} -inline void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { @@ -222,11 +204,11 @@ inline void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &resu Temporal *t = temporal_from_wkb(wkb, input.GetSize()); free(wkb); if (!t) throw InvalidInputException("fromBinary: invalid MEOS-WKB"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } -inline void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { @@ -234,19 +216,19 @@ inline void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &r Temporal *t = temporal_from_hexwkb(hex.c_str()); if (!t) throw InvalidInputException( "fromHexWKB: invalid hex-encoded MEOS-WKB"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } template -inline void TspatialFromStringExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TspatialFromStringExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { std::string s(input.GetData(), input.GetSize()); Temporal *t = FN(s.c_str()); if (!t) throw InvalidInputException("from*: invalid input"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } diff --git a/src/geo/tgeometry_ops.cpp b/src/geo/tgeometry_ops.cpp index d66a936d..56d42cf8 100644 --- a/src/geo/tgeometry_ops.cpp +++ b/src/geo/tgeometry_ops.cpp @@ -3,6 +3,7 @@ // purely registration-and-glue; the heavy lifting stays in libmeos. #include "meos_wrapper_simple.hpp" +#include "temporal/temporal_blob.hpp" #include "common.hpp" #include "geo/tgeometry.hpp" @@ -35,20 +36,14 @@ namespace { // Argument-decoding helpers // ==================================================================== -inline Temporal *DecodeTemporalCopy(string_t blob) { - size_t sz = blob.GetSize(); - Temporal *t = (Temporal *) malloc(sz); - memcpy(t, blob.GetData(), sz); - return t; -} -inline STBox *DecodeStboxCopy(string_t blob) { +static STBox *DecodeStboxCopy(string_t blob) { STBox *b = (STBox *) malloc(sizeof(STBox)); memcpy(b, blob.GetData(), sizeof(STBox)); return b; } -inline Span *DecodeSpanCopy(string_t blob) { +static Span *DecodeSpanCopy(string_t blob) { Span *s = (Span *) malloc(sizeof(Span)); memcpy(s, blob.GetData(), sizeof(Span)); return s; @@ -63,7 +58,7 @@ void TspatialStboxBoolExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t b_blob) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); STBox *b = DecodeStboxCopy(b_blob); bool r = FN(t, b); free(t); free(b); @@ -82,7 +77,7 @@ void StboxTspatialBoolExec(DataChunk &args, ExpressionState &, Vector &result) { args.data[0], args.data[1], result, args.size(), [&](string_t b_blob, string_t t_blob) { STBox *b = DecodeStboxCopy(b_blob); - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); bool r = FN(t, b); free(t); free(b); return r; @@ -94,8 +89,8 @@ void TspatialTspatialBoolExec(DataChunk &args, ExpressionState &, Vector &result BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b) { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); bool r = FN(t1, t2); free(t1); free(t2); return r; @@ -107,7 +102,7 @@ void TemporalTstzspanBoolExec(DataChunk &args, ExpressionState &, Vector &result BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t s_blob) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); Span *s = DecodeSpanCopy(s_blob); bool r = FN(t, s); free(t); free(s); @@ -121,7 +116,7 @@ void TstzspanTemporalBoolExec(DataChunk &args, ExpressionState &, Vector &result args.data[0], args.data[1], result, args.size(), [&](string_t s_blob, string_t t_blob) { Span *s = DecodeSpanCopy(s_blob); - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); bool r = FN(s, t); free(t); free(s); return r; @@ -138,7 +133,7 @@ void TgeoGeoIntExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t g_blob, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(t, gs); @@ -153,7 +148,7 @@ void GeoTgeoIntExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t g_blob, string_t t_blob, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(gs, t); @@ -168,8 +163,8 @@ void TgeoTgeoIntExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); int r = FN(t1, t2); free(t1); free(t2); if (r < 0) { mask.SetInvalid(idx); return false; } @@ -182,7 +177,7 @@ void TgeoGeoDistIntExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t t_blob, string_t g_blob, double dist, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(t, gs, dist); @@ -197,7 +192,7 @@ void GeoTgeoDistIntExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t g_blob, string_t t_blob, double dist, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(gs, t, dist); @@ -214,7 +209,7 @@ void GeoTgeoDistIntExec_FromTgeoGeo(DataChunk &args, ExpressionState &, Vector & TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t g_blob, string_t t_blob, double dist, ValidityMask &mask, idx_t idx) { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); int r = FN(t, gs, dist); @@ -229,8 +224,8 @@ void TgeoTgeoDistIntExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t a, string_t b, double dist, ValidityMask &mask, idx_t idx) { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); int r = FN(t1, t2, dist); free(t1); free(t2); if (r < 0) { mask.SetInvalid(idx); return false; } @@ -244,20 +239,13 @@ void TgeoTgeoDistIntExec(DataChunk &args, ExpressionState &, Vector &result) { // covering the whole input duration. // ==================================================================== -inline string_t TemporalToBlob(Vector &result, Temporal *t) { - size_t sz = temporal_mem_size(t); - string_t out = StringVector::AddStringOrBlob( - result, reinterpret_cast(t), sz); - free(t); - return out; -} template void TgeoGeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t g_blob, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(t, gs); @@ -272,7 +260,7 @@ void GeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t g_blob, string_t t_blob, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(gs, t); @@ -287,8 +275,8 @@ void TgeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); Temporal *r = FN(t1, t2); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } @@ -302,7 +290,7 @@ void TgeoGeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t t_blob, string_t g_blob, double dist, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(t, gs, dist); @@ -317,7 +305,7 @@ void GeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t g_blob, string_t t_blob, double dist, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(gs, t, dist); @@ -332,8 +320,8 @@ void TgeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t a, string_t b, double dist, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); Temporal *r = FN(t1, t2, dist); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } @@ -350,7 +338,7 @@ void TgeoGeoDistanceExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t t_blob, string_t g_blob, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t = DecodeTemporalCopy(t_blob); + Temporal *t = BlobToTemporal(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); Temporal *r = FN(t, gs); @@ -365,8 +353,8 @@ void TgeoTgeoDistanceExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { - Temporal *t1 = DecodeTemporalCopy(a); - Temporal *t2 = DecodeTemporalCopy(b); + Temporal *t1 = BlobToTemporal(a); + Temporal *t2 = BlobToTemporal(b); Temporal *r = FN(t1, t2); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } @@ -380,14 +368,14 @@ void TgeoTgeoDistanceExec(DataChunk &args, ExpressionState &, Vector &result) { // tgeometry <-> tgeompoint coercions. // ==================================================================== -inline string_t StboxToBlob(Vector &result, STBox *box) { +static string_t StboxToBlob(Vector &result, STBox *box) { string_t out = StringVector::AddStringOrBlob( result, reinterpret_cast(box), sizeof(STBox)); free(box); return out; } -inline string_t GeoToBlobAsHex(Vector &result, GSERIALIZED *gs) { +static string_t GeoToBlobAsHex(Vector &result, GSERIALIZED *gs) { if (!gs) return string_t(); size_t sz = 0; uint8_t *ewkb = geo_as_ewkb(gs, NULL, &sz); @@ -402,7 +390,7 @@ void TspatialSridExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); int32_t srid = tspatial_srid(t); free(t); return srid; @@ -413,7 +401,7 @@ void TspatialSetSridExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t blob, int32_t srid) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tspatial_set_srid(t, srid); free(t); if (!r) throw InvalidInputException("setSRID failed"); @@ -425,7 +413,7 @@ void TspatialTransformExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t blob, int32_t srid) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tspatial_transform(t, srid); free(t); if (!r) throw InvalidInputException("transform failed"); @@ -437,7 +425,7 @@ void TspatialToStboxExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); STBox *box = tspatial_to_stbox(t); free(t); return StboxToBlob(result, box); @@ -448,7 +436,7 @@ void TgeometryToTgeompointExec(DataChunk &args, ExpressionState &, Vector &resul UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tgeometry_to_tgeompoint(t); free(t); if (!r) throw InvalidInputException("tgeompoint(tgeometry) failed"); @@ -460,7 +448,7 @@ void TgeompointToTgeometryExec(DataChunk &args, ExpressionState &, Vector &resul UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tgeompoint_to_tgeometry(t); free(t); if (!r) throw InvalidInputException("tgeometry(tgeompoint) failed"); @@ -472,7 +460,7 @@ void TgeoCentroidExec(DataChunk &args, ExpressionState &state, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) -> string_t { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = tgeo_centroid(t); free(t); if (!r) throw InvalidInputException("centroid failed"); @@ -484,7 +472,7 @@ void TgeoConvexHullExec(DataChunk &args, ExpressionState &state, Vector &result) UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t blob) -> string_t { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); GSERIALIZED *gs = tgeo_convex_hull(t); free(t); return GeoToBlobAsHex(result, gs); @@ -497,7 +485,7 @@ void TgeoTraversedAreaExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::Execute( args.data[0], args.data[1], result, cnt, [&](string_t blob, bool unary_union) -> string_t { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); GSERIALIZED *gs = tgeo_traversed_area(t, unary_union); free(t); return GeoToBlobAsHex(result, gs); @@ -506,7 +494,7 @@ void TgeoTraversedAreaExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, cnt, [&](string_t blob) -> string_t { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); GSERIALIZED *gs = tgeo_traversed_area(t, false); free(t); return GeoToBlobAsHex(result, gs); @@ -835,7 +823,7 @@ void TGeometryOps::RegisterScalarFunctions(ExtensionLoader &loader) { result_validity.SetInvalid(i); continue; } - Temporal *t = DecodeTemporalCopy(t_data[i]); + Temporal *t = BlobToTemporal(t_data[i]); GSERIALIZED *origin = geompoint_make3dz(0, 0.0, 0.0, 0.0); int count = 0; STBox *boxes = tgeo_space_boxes( @@ -875,7 +863,7 @@ void TGeometryOps::RegisterScalarFunctions(ExtensionLoader &loader) { result_validity.SetInvalid(i); continue; } - Temporal *t = DecodeTemporalCopy(t_data[i]); + Temporal *t = BlobToTemporal(t_data[i]); GSERIALIZED *origin = geompoint_make3dz(0, 0.0, 0.0, 0.0); MeosInterval iv = IntervaltToInterval(dur_data[i]); constexpr int64_t DEFAULT_TIME_ORIGIN_MEOS = 2LL * 86400LL * 1000000LL; @@ -905,7 +893,7 @@ void TGeometryOps::RegisterScalarFunctions(ExtensionLoader &loader) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t blob, double eps) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); Temporal *r = FN(t, eps); free(t); if (!r) throw InvalidInputException("simplify failed"); @@ -929,7 +917,7 @@ void TGeometryOps::RegisterScalarFunctions(ExtensionLoader &loader) { continue; } bool sync = has_third ? FlatVector::GetData(args.data[2])[i] : true; - Temporal *t = DecodeTemporalCopy(blob_data[i]); + Temporal *t = BlobToTemporal(blob_data[i]); Temporal *r = FN(t, eps_data[i], sync); free(t); if (!r) { @@ -951,7 +939,7 @@ void TGeometryOps::RegisterScalarFunctions(ExtensionLoader &loader) { BinaryExecutor::Execute( args.data[0], args.data[1], result, args.size(), [&](string_t blob, interval_t iv) { - Temporal *t = DecodeTemporalCopy(blob); + Temporal *t = BlobToTemporal(blob); MeosInterval miv = IntervaltToInterval(iv); Temporal *r = temporal_simplify_min_tdelta(t, &miv); free(t); diff --git a/src/geo/tgeompoint.cpp b/src/geo/tgeompoint.cpp index 7111d6b8..26db8ed3 100644 --- a/src/geo/tgeompoint.cpp +++ b/src/geo/tgeompoint.cpp @@ -1,4 +1,5 @@ #include "meos_wrapper_simple.hpp" +#include "temporal/temporal_blob.hpp" #include "common.hpp" #include "geo/tgeompoint.hpp" @@ -1775,12 +1776,6 @@ namespace { constexpr uint8_t WKB_BASE = 0x00; /* WKB_EXTENDED is provided by meos_geo.h as #define WKB_EXTENDED 0x04 */ -inline Temporal *BlobToTemp(string_t b) { - size_t sz = b.GetSize(); - uint8_t *copy = (uint8_t *)malloc(sz); - memcpy(copy, b.GetData(), sz); - return reinterpret_cast(copy); -} inline Temporal *BlobToTempMVT(string_t b) { size_t sz = b.GetSize(); @@ -1799,7 +1794,7 @@ void TgeoAsWkbExec(DataChunk &args, ExpressionState &state, Vector &result, uint UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { - Temporal *t = BlobToTemp(input); + Temporal *t = BlobToTemporal(input); size_t sz = 0; uint8_t *wkb = temporal_as_wkb(t, variant, &sz); free(t); @@ -1818,7 +1813,7 @@ void TgeoAsHexWkbExec(DataChunk &args, ExpressionState &state, Vector &result, u UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { - Temporal *t = BlobToTemp(input); + Temporal *t = BlobToTemporal(input); size_t sz = 0; char *hex = temporal_as_hexwkb(t, variant, &sz); (void) sz; @@ -1873,7 +1868,7 @@ void TgeoAsMfjsonExec(DataChunk &args, ExpressionState &state, Vector &result) { out_validity.SetInvalid(row); continue; } - Temporal *t = BlobToTemp(in[row]); + Temporal *t = BlobToTemporal(in[row]); bool with_bbox = (cc > 1) ? FlatVector::GetData(args.data[1])[row] : false; int flags = (cc > 2) ? FlatVector::GetData(args.data[2])[row] : 0; int precision = (cc > 3) ? FlatVector::GetData(args.data[3])[row] : 15; @@ -1893,7 +1888,6 @@ void TgeoAsMfjsonExec(DataChunk &args, ExpressionState &state, Vector &result) { out_data[row] = StringVector::AddString(result, json); free(json); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } inline STBox *BlobToStboxMVT(string_t b) { @@ -1969,7 +1963,6 @@ void TgeoAsMVTGeomExec(DataChunk &args, ExpressionState &state, Vector &result) } if (times) free(times); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TgeoFromMfjsonExec(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2261,7 +2254,6 @@ void TgeoGeoMeasureExec(DataChunk &args, ExpressionState &state, Vector &result) out_data[row] = StringVector::AddStringOrBlob(result, enc); free(geom); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } } // namespace diff --git a/src/geo/tgeompoint_functions.cpp b/src/geo/tgeompoint_functions.cpp index d063f23f..20b851dd 100644 --- a/src/geo/tgeompoint_functions.cpp +++ b/src/geo/tgeompoint_functions.cpp @@ -153,9 +153,6 @@ static void spatialarr_wkt_array(DataChunk &args, ExpressionState &state, Vector ListVector::SetListSize(result, total_offset); - if (row_count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } } // namespace @@ -192,9 +189,6 @@ bool TgeompointFunctions::Tpoint_in(Vector &source, Vector &result, idx_t count, return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -228,9 +222,6 @@ void TgeompointFunctions::Tspatial_as_text(DataChunk &args, ExpressionState &sta return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { @@ -263,9 +254,6 @@ void TgeompointFunctions::Tspatial_as_ewkt(DataChunk &args, ExpressionState &sta return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Spatialarr_as_text(DataChunk &args, ExpressionState &state, Vector &result) { @@ -318,12 +306,9 @@ void TgeompointFunctions::Tpointinst_constructor(DataChunk &args, ExpressionStat free(ret_data); return stored_data; }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tspatial_to_stbox_common(Vector &source, Vector &result, idx_t count) { +static void Tspatial_to_stbox_common(Vector &source, Vector &result, idx_t count) { UnaryExecutor::Execute( source, result, count, [&](string_t input_blob) -> string_t { @@ -361,9 +346,6 @@ inline void Tspatial_to_stbox_common(Vector &source, Vector &result, idx_t count return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tspatial_to_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -405,9 +387,6 @@ void TgeompointFunctions::Tgeompoint_start_value(DataChunk &args, ExpressionStat return stored_result; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tgeompoint_end_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -440,9 +419,6 @@ void TgeompointFunctions::Tgeompoint_end_value(DataChunk &args, ExpressionState return stored_result; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tgeompoint_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { @@ -549,16 +525,13 @@ void TgeompointFunctions::Tgeompoint_sequence_constructor(DataChunk &args, Expre return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** * Conversion functions ****************************************************/ -inline void Temporal_to_tstzspan_common(Vector &source, Vector &result, idx_t count) { +static void Temporal_to_tstzspan_common(Vector &source, Vector &result, idx_t count) { UnaryExecutor::Execute( source, result, count, [&](string_t input_blob) { @@ -588,9 +561,6 @@ inline void Temporal_to_tstzspan_common(Vector &source, Vector &result, idx_t co return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { @@ -639,9 +609,6 @@ void TgeompointFunctions::Tgeompoint_value(DataChunk &args, ExpressionState &sta return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -692,9 +659,6 @@ void TgeompointFunctions::Tgeompoint_at_value(DataChunk &args, ExpressionState & return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tgeompoint_value_at_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { @@ -733,9 +697,6 @@ void TgeompointFunctions::Tgeompoint_value_at_timestamptz(DataChunk &args, Expre return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -773,9 +734,6 @@ void TgeompointFunctions::Tgeompoint_stops(DataChunk &args, ExpressionState &sta return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -809,9 +767,6 @@ void TgeompointFunctions::Tpoint_get_x(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tpoint_get_y(DataChunk &args, ExpressionState &state, Vector &result) { @@ -842,9 +797,6 @@ void TgeompointFunctions::Tpoint_get_y(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tpoint_get_z(DataChunk &args, ExpressionState &state, Vector &result) { @@ -875,9 +827,6 @@ void TgeompointFunctions::Tpoint_get_z(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tpoint_length(DataChunk &args, ExpressionState &state, Vector &result) { @@ -898,9 +847,6 @@ void TgeompointFunctions::Tpoint_length(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tpoint_cumulative_length(DataChunk &args, ExpressionState &state, Vector &result) { @@ -931,9 +877,6 @@ void TgeompointFunctions::Tpoint_cumulative_length(DataChunk &args, ExpressionSt return stored_result; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tpoint_twcentroid(DataChunk &args, ExpressionState &state, Vector &result) { @@ -960,9 +903,6 @@ void TgeompointFunctions::Tpoint_twcentroid(DataChunk &args, ExpressionState &st return stored_result; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tpoint_direction(DataChunk &args, ExpressionState &state, Vector &result) { @@ -988,9 +928,6 @@ void TgeompointFunctions::Tpoint_direction(DataChunk &args, ExpressionState &sta return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tpoint_azimuth(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1021,9 +958,6 @@ void TgeompointFunctions::Tpoint_azimuth(DataChunk &args, ExpressionState &state return stored_result; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tpoint_angular_difference(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1054,9 +988,6 @@ void TgeompointFunctions::Tpoint_angular_difference(DataChunk &args, ExpressionS return stored_result; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tpoint_is_simple(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1077,72 +1008,68 @@ void TgeompointFunctions::Tpoint_is_simple(DataChunk &args, ExpressionState &sta return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tpoint_make_simple(DataChunk &args, ExpressionState &state, Vector &result) { - idx_t total_count = 0; - UnaryExecutor::Execute( - args.data[0], result, args.size(), - [&](string_t input_blob) -> list_entry_t { - const uint8_t *data = reinterpret_cast(input_blob.GetData()); - size_t data_size = input_blob.GetSize(); - if (data_size < sizeof(void *)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); - } - uint8_t *data_copy = (uint8_t *)malloc(data_size); - memcpy(data_copy, data, data_size); - Temporal *temp = reinterpret_cast(data_copy); - if (!temp) { - free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } + const idx_t count = args.size(); - int frag_count = 0; - Temporal **fragments = tpoint_make_simple(temp, &frag_count); - free(data_copy); + UnifiedVectorFormat in; + args.data[0].ToUnifiedFormat(count, in); + auto in_data = UnifiedVectorFormat::GetData(in); - if (!fragments || frag_count <= 0) { - if (fragments) { - free(fragments); - } - throw InvalidInputException("makeSimple: failed to split temporal point"); - } + auto list_data = FlatVector::GetData(result); + auto &result_validity = FlatVector::Validity(result); + auto &child_vec = ListVector::GetEntry(result); + idx_t offset = 0; - const list_entry_t entry(total_count, static_cast(frag_count)); - total_count += frag_count; - ListVector::Reserve(result, total_count); - - auto &child_vec = ListVector::GetEntry(result); - auto child_data = FlatVector::GetData(child_vec); - - for (int i = 0; i < frag_count; i++) { - Temporal *frag = fragments[i]; - if (!frag) { - for (int k = i; k < frag_count; k++) { - if (fragments[k]) { - free(fragments[k]); - } - } - free(fragments); - throw InvalidInputException("makeSimple: null fragment in result array"); - } - size_t frag_size = temporal_mem_size(frag); - uint8_t *frag_buf = (uint8_t *)malloc(frag_size); - memcpy(frag_buf, frag, frag_size); - string_t frag_blob(reinterpret_cast(frag_buf), frag_size); - string_t stored = StringVector::AddStringOrBlob(child_vec, frag_blob); - free(frag_buf); - free(frag); - child_data[entry.offset + static_cast(i)] = stored; - } - free(fragments); - return entry; - }); - ListVector::SetListSize(result, total_count); - if (args.size() == 1) { + for (idx_t row = 0; row < count; row++) { + const idx_t idx = in.sel->get_index(row); + if (!in.validity.RowIsValid(idx)) { + result_validity.SetInvalid(row); + continue; + } + + const string_t &input_blob = in_data[idx]; + size_t data_size = input_blob.GetSize(); + if (data_size < sizeof(void *)) { + throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); + } + uint8_t *data_copy = (uint8_t *)malloc(data_size); + memcpy(data_copy, input_blob.GetData(), data_size); + Temporal *temp = reinterpret_cast(data_copy); + + int frag_count = 0; + Temporal **fragments = tpoint_make_simple(temp, &frag_count); + if (!fragments || frag_count <= 0) { + free(data_copy); + if (fragments) { + free(fragments); + } + throw InvalidInputException("makeSimple: failed to split temporal point"); + } + + // Reserve the child capacity for this row's fragments, then re-fetch the + // child data pointer: Reserve may reallocate the child's data array. + ListVector::Reserve(result, offset + frag_count); + auto child_data = FlatVector::GetData(child_vec); + + for (int i = 0; i < frag_count; i++) { + Temporal *frag = fragments[i]; + size_t frag_size = temporal_mem_size(frag); + child_data[offset + static_cast(i)] = + StringVector::AddStringOrBlob(child_vec, + string_t(reinterpret_cast(frag), frag_size)); + free(frag); + } + free(fragments); + free(data_copy); + + list_data[row] = list_entry_t(offset, static_cast(frag_count)); + offset += frag_count; + } + + ListVector::SetListSize(result, offset); + if (args.AllConstant()) { result.SetVectorType(VectorType::CONSTANT_VECTOR); } } @@ -1175,9 +1102,6 @@ void TgeompointFunctions::Tpoint_trajectory(DataChunk &args, ExpressionState &st return stored_result; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tpoint_trajectory_gs(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1211,9 +1135,6 @@ void TgeompointFunctions::Tpoint_trajectory_gs(DataChunk &args, ExpressionState return stored_result; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tgeo_at_geom(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1256,9 +1177,6 @@ void TgeompointFunctions::Tgeo_at_geom(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tgeo_minus_geom(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1304,9 +1222,6 @@ void TgeompointFunctions::Tgeo_minus_geom(DataChunk &args, ExpressionState &stat return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tgeo_minus_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1357,9 +1272,6 @@ void TgeompointFunctions::Tgeo_minus_stbox(DataChunk &args, ExpressionState &sta return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tgeo_at_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1419,9 +1331,6 @@ void TgeompointFunctions::Tgeo_at_stbox(DataChunk &args, ExpressionState &state, return run(tgeom_blob, stbox_blob, border_inc, mask, idx); }); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tspatial_transform(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1462,9 +1371,6 @@ void TgeompointFunctions::Tspatial_transform(DataChunk &args, ExpressionState &s return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -1501,9 +1407,6 @@ void TgeompointFunctions::Econtains_geo_tgeo(DataChunk &args, ExpressionState &s return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Acontains_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1537,9 +1440,6 @@ void TgeompointFunctions::Acontains_geo_tgeo(DataChunk &args, ExpressionState &s return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Edisjoint_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1576,9 +1476,6 @@ void TgeompointFunctions::Edisjoint_geo_tgeo(DataChunk &args, ExpressionState &s return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Edisjoint_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1615,9 +1512,6 @@ void TgeompointFunctions::Edisjoint_tgeo_geo(DataChunk &args, ExpressionState &s return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Edisjoint_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1655,9 +1549,6 @@ void TgeompointFunctions::Edisjoint_tgeo_tgeo(DataChunk &args, ExpressionState & return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Adisjoint_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1695,9 +1586,6 @@ void TgeompointFunctions::Adisjoint_geo_tgeo(DataChunk &args, ExpressionState &s return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Adisjoint_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1734,9 +1622,6 @@ void TgeompointFunctions::Adisjoint_tgeo_geo(DataChunk &args, ExpressionState &s return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Adisjoint_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1775,9 +1660,6 @@ void TgeompointFunctions::Adisjoint_tgeo_tgeo(DataChunk &args, ExpressionState & return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Eintersects_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1815,9 +1697,6 @@ void TgeompointFunctions::Eintersects_tgeo_tgeo(DataChunk &args, ExpressionState return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Eintersects_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1851,9 +1730,6 @@ void TgeompointFunctions::Eintersects_geo_tgeo(DataChunk &args, ExpressionState return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Eintersects_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1887,9 +1763,6 @@ void TgeompointFunctions::Eintersects_tgeo_geo(DataChunk &args, ExpressionState return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Aintersects_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1922,9 +1795,6 @@ void TgeompointFunctions::Aintersects_geo_tgeo(DataChunk &args, ExpressionState return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Aintersects_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1958,9 +1828,6 @@ void TgeompointFunctions::Aintersects_tgeo_geo(DataChunk &args, ExpressionState return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Aintersects_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1998,9 +1865,6 @@ void TgeompointFunctions::Aintersects_tgeo_tgeo(DataChunk &args, ExpressionState return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Etouches_geo_tpoint(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2036,9 +1900,6 @@ void TgeompointFunctions::Etouches_geo_tpoint(DataChunk &args, ExpressionState & } return ret; }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Atouches_geo_tpoint(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2074,9 +1935,6 @@ void TgeompointFunctions::Atouches_geo_tpoint(DataChunk &args, ExpressionState & } return ret; }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Etouches_tpoint_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2110,9 +1968,6 @@ void TgeompointFunctions::Etouches_tpoint_geo(DataChunk &args, ExpressionState & return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Atouches_tpoint_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2146,9 +2001,6 @@ void TgeompointFunctions::Atouches_tpoint_geo(DataChunk &args, ExpressionState & return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Edwithin_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2186,9 +2038,6 @@ void TgeompointFunctions::Edwithin_tgeo_tgeo(DataChunk &args, ExpressionState &s return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Edwithin_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2222,9 +2071,6 @@ void TgeompointFunctions::Edwithin_tgeo_geo(DataChunk &args, ExpressionState &st return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Edwithin_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2261,9 +2107,6 @@ void TgeompointFunctions::Edwithin_geo_tgeo(DataChunk &args, ExpressionState &st return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Adwithin_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2300,9 +2143,6 @@ void TgeompointFunctions::Adwithin_tgeo_geo(DataChunk &args, ExpressionState &st return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Adwithin_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2339,9 +2179,6 @@ void TgeompointFunctions::Adwithin_geo_tgeo(DataChunk &args, ExpressionState &st return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Adwithin_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2379,9 +2216,6 @@ void TgeompointFunctions::Adwithin_tgeo_tgeo(DataChunk &args, ExpressionState &s return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -2422,9 +2256,6 @@ void TgeompointFunctions::Tcontains_geo_tgeo(DataChunk &args, ExpressionState &s free(ret); return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tdisjoint_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2461,9 +2292,6 @@ void TgeompointFunctions::Tdisjoint_geo_tgeo(DataChunk &args, ExpressionState &s return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tdisjoint_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2500,9 +2328,6 @@ void TgeompointFunctions::Tdisjoint_tgeo_geo(DataChunk &args, ExpressionState &s return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tdisjoint_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2543,9 +2368,6 @@ void TgeompointFunctions::Tdisjoint_tgeo_tgeo(DataChunk &args, ExpressionState & return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tintersects_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2582,9 +2404,6 @@ void TgeompointFunctions::Tintersects_geo_tgeo(DataChunk &args, ExpressionState return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tintersects_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2621,9 +2440,6 @@ void TgeompointFunctions::Tintersects_tgeo_geo(DataChunk &args, ExpressionState return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tintersects_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2664,9 +2480,6 @@ void TgeompointFunctions::Tintersects_tgeo_tgeo(DataChunk &args, ExpressionState return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Ttouches_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2703,9 +2516,6 @@ void TgeompointFunctions::Ttouches_geo_tgeo(DataChunk &args, ExpressionState &st return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Ttouches_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2742,9 +2552,6 @@ void TgeompointFunctions::Ttouches_tgeo_geo(DataChunk &args, ExpressionState &st return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tdwithin_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2786,9 +2593,6 @@ void TgeompointFunctions::Tdwithin_tgeo_tgeo(DataChunk &args, ExpressionState &s return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tdwithin_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2825,9 +2629,6 @@ void TgeompointFunctions::Tdwithin_tgeo_geo(DataChunk &args, ExpressionState &st return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tdwithin_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2864,9 +2665,6 @@ void TgeompointFunctions::Tdwithin_geo_tgeo(DataChunk &args, ExpressionState &st return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::ShortestLine_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2908,9 +2706,6 @@ void TgeompointFunctions::ShortestLine_tgeo_tgeo(DataChunk &args, ExpressionStat return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -2947,9 +2742,6 @@ void TgeompointFunctions::Temporal_overlaps_tgeompoint_stbox(DataChunk &args, Ex return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Temporal_overlaps_tgeompoint_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2982,9 +2774,6 @@ void TgeompointFunctions::Temporal_overlaps_tgeompoint_tstzspan(DataChunk &args, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Temporal_contains_tgeompoint_stbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3017,9 +2806,6 @@ void TgeompointFunctions::Temporal_contains_tgeompoint_stbox(DataChunk &args, Ex return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -3070,9 +2856,6 @@ void TgeompointFunctions::Tdistance_tgeo_tgeo(DataChunk &args, ExpressionState & return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // void TgeompointFunctions::gs_as_text(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3171,9 +2954,6 @@ void TgeompointFunctions::collect_gs(DataChunk &args, ExpressionState &state, Ve return stored_result; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::distance_geo_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3207,9 +2987,6 @@ void TgeompointFunctions::distance_geo_geo(DataChunk &args, ExpressionState &sta return distance; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -3406,9 +3183,6 @@ void TgeompointFunctions::Tgeo_rotate_geom(DataChunk &args, ExpressionState &sta out_data[row] = ApplyAffineToTgeoStraggler(result, in_data[row], m); } - if (row_count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tgeo_scale_xy(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3435,9 +3209,6 @@ void TgeompointFunctions::Tgeo_scale_xy(DataChunk &args, ExpressionState &state, m.efac = sy_data[row]; out_data[row] = ApplyAffineToTgeoStraggler(result, in_data[row], m); } - if (row_count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TgeompointFunctions::Tgeo_scale_xyz(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3469,9 +3240,6 @@ void TgeompointFunctions::Tgeo_scale_xyz(DataChunk &args, ExpressionState &state m.ifac = sz_data[row]; out_data[row] = ApplyAffineToTgeoStraggler(result, in_data[row], m); } - if (row_count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -3525,7 +3293,6 @@ void TgeompointFunctions::Nai_tgeo_geo(DataChunk &args, ExpressionState &state, if (!inst) { outv.SetInvalid(i); continue; } out[i] = NaiToHex(result, inst); } - if (n == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TgeompointFunctions::Nai_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3551,7 +3318,6 @@ void TgeompointFunctions::Nai_geo_tgeo(DataChunk &args, ExpressionState &state, if (!inst) { outv.SetInvalid(i); continue; } out[i] = NaiToHex(result, inst); } - if (n == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TgeompointFunctions::Nad_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3668,7 +3434,6 @@ void TgeompointFunctions::Tgeo_affine_12(DataChunk &args, ExpressionState &state m.xoff = xoff[i]; m.yoff = yoff[i]; m.zoff = zoff[i]; out[i] = ApplyAffineToTgeo(result, in[i], m); } - if (n == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TgeompointFunctions::Tgeo_affine_6(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3693,7 +3458,6 @@ void TgeompointFunctions::Tgeo_affine_6(DataChunk &args, ExpressionState &state, m.xoff = xoff[i]; m.yoff = yoff[i]; out[i] = ApplyAffineToTgeo(result, in[i], m); } - if (n == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TgeompointFunctions::Tgeo_translate_3d(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3713,7 +3477,6 @@ void TgeompointFunctions::Tgeo_translate_3d(DataChunk &args, ExpressionState &st m.xoff = dx[i]; m.yoff = dy[i]; m.zoff = dz[i]; out[i] = ApplyAffineToTgeo(result, in[i], m); } - if (n == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TgeompointFunctions::Tgeo_translate_2d(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3732,7 +3495,6 @@ void TgeompointFunctions::Tgeo_translate_2d(DataChunk &args, ExpressionState &st m.xoff = dx[i]; m.yoff = dy[i]; out[i] = ApplyAffineToTgeo(result, in[i], m); } - if (n == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TgeompointFunctions::Tgeo_rotate_angle(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3752,7 +3514,6 @@ void TgeompointFunctions::Tgeo_rotate_angle(DataChunk &args, ExpressionState &st m.dfac = s; m.efac = c; out[i] = ApplyAffineToTgeo(result, in[i], m); } - if (n == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TgeompointFunctions::Tgeo_rotate_angle_cx_cy(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3777,7 +3538,6 @@ void TgeompointFunctions::Tgeo_rotate_angle_cx_cy(DataChunk &args, ExpressionSta m.yoff = cy - s * cx - c * cy; out[i] = ApplyAffineToTgeo(result, in[i], m); } - if (n == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TgeompointFunctions::Tgeo_rotateX(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3798,7 +3558,6 @@ void TgeompointFunctions::Tgeo_rotateX(DataChunk &args, ExpressionState &state, m.hfac = s; m.ifac = c; out[i] = ApplyAffineToTgeo(result, in[i], m); } - if (n == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TgeompointFunctions::Tgeo_rotateY(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3819,7 +3578,6 @@ void TgeompointFunctions::Tgeo_rotateY(DataChunk &args, ExpressionState &state, m.gfac = -s; m.ifac = c; out[i] = ApplyAffineToTgeo(result, in[i], m); } - if (n == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TgeompointFunctions::Tgeo_transscale(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3841,7 +3599,6 @@ void TgeompointFunctions::Tgeo_transscale(DataChunk &args, ExpressionState &stat m.xoff = dx[i] * sx[i]; m.yoff = dy[i] * sy[i]; out[i] = ApplyAffineToTgeo(result, in[i], m); } - if (n == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TgeompointFunctions::Tgeo_scale_geom(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3871,7 +3628,6 @@ void TgeompointFunctions::Tgeo_scale_geom(DataChunk &args, ExpressionState &stat out[i] = StringVector::AddStringOrBlob(result, string_t(reinterpret_cast(rbuf), rsz)); free(rbuf); free(ret); } - if (n == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TgeompointFunctions::Tgeo_scale_geom_origin(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3904,7 +3660,6 @@ void TgeompointFunctions::Tgeo_scale_geom_origin(DataChunk &args, ExpressionStat out[i] = StringVector::AddStringOrBlob(result, string_t(reinterpret_cast(rbuf), rsz)); free(rbuf); free(ret); } - if (n == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } } // namespace duckdb diff --git a/src/geo/tnpoint.cpp b/src/geo/tnpoint.cpp index fcf88933..974044a0 100644 --- a/src/geo/tnpoint.cpp +++ b/src/geo/tnpoint.cpp @@ -36,7 +36,7 @@ LogicalType TNpointTypes::TNPOINT() { * Constructors */ -inline void Tnpoint_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tnpoint_constructor(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -69,12 +69,9 @@ inline void Tnpoint_constructor(DataChunk &args, ExpressionState &state, Vector return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tnpointinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tnpointinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &value_vec = args.data[0]; auto &t_vec = args.data[1]; @@ -127,13 +124,10 @@ inline void Tnpointinst_constructor(DataChunk &args, ExpressionState &state, Vec }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tnpoint_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tnpoint_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { const char* default_interp = "linear"; auto count = args.size(); auto arg_count = args.ColumnCount(); @@ -198,9 +192,6 @@ inline void Tnpoint_sequence_from_tstzspan(DataChunk &args, ExpressionState &sta }); - if (count == 1){ - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } TInstant **temparr_extract_np(Vector &tnpoint_arr_vec, list_entry_t list_entry, int *count) { @@ -265,7 +256,7 @@ TInstant **temparr_extract_np(Vector &tnpoint_arr_vec, list_entry_t list_entry, return instants; } -inline void Tnpoint_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tnpoint_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { // Default values const char* default_interp = "linear"; bool default_lower_inc = true; @@ -399,9 +390,6 @@ inline void Tnpoint_sequence_constructor(DataChunk &args, ExpressionState &state } } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -411,7 +399,7 @@ inline void Tnpoint_sequence_constructor(DataChunk &args, ExpressionState &state * Conversions */ -inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -452,16 +440,13 @@ inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* * Transformations */ -inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -501,13 +486,10 @@ inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; auto &interp_vec = args.data[1]; @@ -552,13 +534,10 @@ inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom1_vec = args.data[0]; auto &tgeom2_vec = args.data[1]; @@ -606,9 +585,6 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -616,7 +592,7 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu * Accessor Functions */ -inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -643,15 +619,12 @@ inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &re return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -680,12 +653,9 @@ inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &res return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -707,9 +677,6 @@ inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r return static_cast(mem_size); }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // ---- Network-point value accessors ---- @@ -732,7 +699,7 @@ inline Npoint *npoint_from_instant_value(const TInstant *inst) { return reinterpret_cast(d); } -inline void Tnpoint_get_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tnpoint_get_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -761,14 +728,11 @@ inline void Tnpoint_get_value(DataChunk &args, ExpressionState &state, Vector &r return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tnpoint_start_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tnpoint_start_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -798,13 +762,10 @@ inline void Tnpoint_start_value(DataChunk &args, ExpressionState &state, Vector return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tnpoint_end_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tnpoint_end_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -834,12 +795,9 @@ inline void Tnpoint_end_value(DataChunk &args, ExpressionState &state, Vector &r return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tnpoint_route(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tnpoint_route(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -859,13 +817,10 @@ inline void Tnpoint_route(DataChunk &args, ExpressionState &state, Vector &resul return static_cast(rid); }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -883,12 +838,9 @@ inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -906,12 +858,9 @@ inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -948,12 +897,9 @@ inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vect return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -990,15 +936,12 @@ inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; auto &n_vec = args.data[1]; @@ -1035,13 +978,10 @@ inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -1079,9 +1019,6 @@ inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } diff --git a/src/geo/tnpoint_in_out.cpp b/src/geo/tnpoint_in_out.cpp index ea9b8e99..ff55bb20 100644 --- a/src/geo/tnpoint_in_out.cpp +++ b/src/geo/tnpoint_in_out.cpp @@ -1,4 +1,5 @@ #include "geo/tnpoint.hpp" +#include "temporal/temporal_blob.hpp" #include "duckdb/main/extension/extension_loader.hpp" #include "duckdb/common/extension_type_info.hpp" #include @@ -16,7 +17,7 @@ extern "C" { namespace duckdb { -inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -43,7 +44,7 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re throw InvalidInputException("Invalid TNPOINT data: null pointer"); } - char *str = tspatial_as_text(temp, 0); + char *str = tspatial_as_text(temp, 15); if (!str) { free(data_copy); @@ -60,12 +61,9 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -93,7 +91,7 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re throw InvalidInputException("Invalid TNPOINT data: null pointer"); } - char *ewkt = tspatial_as_ewkt(temp, 0); + char *ewkt = tspatial_as_ewkt(temp, 15); if (!ewkt) { free(data_copy); @@ -111,9 +109,6 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -146,9 +141,6 @@ bool TnpointFunctions::StringToTnpoint(Vector &source, Vector &result, idx_t cou return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -190,9 +182,6 @@ bool TnpointFunctions::TnpointToString(Vector &source, Vector &result, idx_t cou return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -208,15 +197,8 @@ bool TnpointFunctions::TnpointToString(Vector &source, Vector &result, idx_t cou // generic Temporal_from_mfjson handler. The result is stored as a raw // blob, the same format every other temporal type uses. -inline string_t StoreTempAsBlob(Vector &result, Temporal *t) { - size_t sz = temporal_mem_size(t); - string_t stored = StringVector::AddStringOrBlob( - result, string_t(reinterpret_cast(t), sz)); - free(t); - return stored; -} -inline void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { @@ -228,11 +210,11 @@ inline void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &resu Temporal *t = temporal_from_wkb(wkb, input.GetSize()); free(wkb); if (!t) throw InvalidInputException("fromBinary: invalid MEOS-WKB"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } -inline void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { @@ -240,22 +222,22 @@ inline void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &r Temporal *t = temporal_from_hexwkb(hex.c_str()); if (!t) throw InvalidInputException( "fromHexWKB: invalid hex-encoded MEOS-WKB"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } -inline void TnpointFromTextExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TnpointFromTextExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { std::string s(input.GetData(), input.GetSize()); Temporal *t = tnpoint_in(s.c_str()); if (!t) throw InvalidInputException("from*: invalid input"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } -inline void TnpointFromMFJSONExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TnpointFromMFJSONExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { @@ -265,7 +247,7 @@ inline void TnpointFromMFJSONExec(DataChunk &args, ExpressionState &, Vector &re // same path the canonical MobilityDB SQL binds. Temporal *t = temporal_from_mfjson(s.c_str(), T_TNPOINT); if (!t) throw InvalidInputException("fromMFJSON: invalid input"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } @@ -308,8 +290,8 @@ void TNpointTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ void TNpointTypes::RegisterCastFunctions(ExtensionLoader &loader) { - loader.RegisterCastFunction( LogicalType::VARCHAR, TNpointTypes::TNPOINT(), TnpointFunctions::StringToTnpoint); - loader.RegisterCastFunction( TNpointTypes::TNPOINT(), LogicalType::VARCHAR, TnpointFunctions::TnpointToString); + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, TNpointTypes::TNPOINT(), TnpointFunctions::StringToTnpoint); + RegisterMeosCastFunction(loader, TNpointTypes::TNPOINT(), LogicalType::VARCHAR, TnpointFunctions::TnpointToString); } } diff --git a/src/geo/tpose.cpp b/src/geo/tpose.cpp index 34d7cd3b..d6469cb7 100644 --- a/src/geo/tpose.cpp +++ b/src/geo/tpose.cpp @@ -36,7 +36,7 @@ LogicalType TPoseTypes::TPOSE() { * Constructors */ -inline void Tpose_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tpose_constructor(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -69,12 +69,9 @@ inline void Tpose_constructor(DataChunk &args, ExpressionState &state, Vector &r return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tposeinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tposeinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &value_vec = args.data[0]; auto &t_vec = args.data[1]; @@ -127,13 +124,10 @@ inline void Tposeinst_constructor(DataChunk &args, ExpressionState &state, Vecto }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tpose_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tpose_sequence_from_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { const char* default_interp = "linear"; auto count = args.size(); auto arg_count = args.ColumnCount(); @@ -198,9 +192,6 @@ inline void Tpose_sequence_from_tstzspan(DataChunk &args, ExpressionState &state }); - if (count == 1){ - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } TInstant **temparr_extract_ps(Vector &tpose_arr_vec, list_entry_t list_entry, int *count) { @@ -265,7 +256,7 @@ TInstant **temparr_extract_ps(Vector &tpose_arr_vec, list_entry_t list_entry, in return instants; } -inline void Tpose_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tpose_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { // Default values const char* default_interp = "linear"; bool default_lower_inc = true; @@ -399,9 +390,6 @@ inline void Tpose_sequence_constructor(DataChunk &args, ExpressionState &state, } } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -411,7 +399,7 @@ inline void Tpose_sequence_constructor(DataChunk &args, ExpressionState &state, * Conversions */ -inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -452,16 +440,13 @@ inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* * Transformations */ -inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -501,13 +486,10 @@ inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; auto &interp_vec = args.data[1]; @@ -552,13 +534,10 @@ inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom1_vec = args.data[0]; auto &tgeom2_vec = args.data[1]; @@ -606,9 +585,6 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -616,7 +592,7 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu * Accessor Functions */ -inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -643,15 +619,12 @@ inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &re return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -680,12 +653,9 @@ inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &res return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -707,9 +677,6 @@ inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r return static_cast(mem_size); }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // ---- Pose value accessors ---- @@ -721,12 +688,12 @@ inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r // returns the position geometry via pose_to_point and rotation(tpose) // returns the 2D rotation angle via pose_rotation, per the manual model. -inline Pose *pose_from_instant_value(const TInstant *inst) { +static Pose *pose_from_instant_value(const TInstant *inst) { Datum d = tinstant_value(inst); return reinterpret_cast(d); } -inline void Tpose_get_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tpose_get_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -755,14 +722,11 @@ inline void Tpose_get_value(DataChunk &args, ExpressionState &state, Vector &res return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tpose_start_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tpose_start_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -792,13 +756,10 @@ inline void Tpose_start_value(DataChunk &args, ExpressionState &state, Vector &r return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tpose_end_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tpose_end_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -828,12 +789,9 @@ inline void Tpose_end_value(DataChunk &args, ExpressionState &state, Vector &res return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tpose_point(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tpose_point(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -866,12 +824,9 @@ inline void Tpose_point(DataChunk &args, ExpressionState &state, Vector &result) return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tpose_rotation(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tpose_rotation(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -893,13 +848,10 @@ inline void Tpose_rotation(DataChunk &args, ExpressionState &state, Vector &resu return theta; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -917,12 +869,9 @@ inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -940,12 +889,9 @@ inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -982,12 +928,9 @@ inline void Temporal_start_instant(DataChunk &args, ExpressionState &state, Vect return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -1024,15 +967,12 @@ inline void Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; auto &n_vec = args.data[1]; @@ -1069,13 +1009,10 @@ inline void Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -1113,9 +1050,6 @@ inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } diff --git a/src/geo/tpose_in_out.cpp b/src/geo/tpose_in_out.cpp index 05d5e754..45c44cf3 100644 --- a/src/geo/tpose_in_out.cpp +++ b/src/geo/tpose_in_out.cpp @@ -1,4 +1,5 @@ #include "geo/tpose.hpp" +#include "temporal/temporal_blob.hpp" #include "duckdb/main/extension/extension_loader.hpp" #include "duckdb/common/extension_type_info.hpp" #include @@ -16,7 +17,7 @@ extern "C" { namespace duckdb { -inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -43,7 +44,7 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re throw InvalidInputException("Invalid TPOSE data: null pointer"); } - char *str = tspatial_as_text(temp, 0); + char *str = tspatial_as_text(temp, 15); if (!str) { free(data_copy); @@ -60,12 +61,9 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -93,7 +91,7 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re throw InvalidInputException("Invalid TPOSE data: null pointer"); } - char *ewkt = tspatial_as_ewkt(temp, 0); + char *ewkt = tspatial_as_ewkt(temp, 15); if (!ewkt) { free(data_copy); @@ -111,9 +109,6 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -146,9 +141,6 @@ bool TposeFunctions::StringToTpose(Vector &source, Vector &result, idx_t count, return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -190,9 +182,6 @@ bool TposeFunctions::TposeToString(Vector &source, Vector &result, idx_t count, return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -210,15 +199,8 @@ bool TposeFunctions::TposeToString(Vector &source, Vector &result, idx_t count, // Temporal_from_mfjson handler. The result is stored as a raw blob, // the same format every other temporal type uses. -inline string_t StoreTempAsBlob(Vector &result, Temporal *t) { - size_t sz = temporal_mem_size(t); - string_t stored = StringVector::AddStringOrBlob( - result, string_t(reinterpret_cast(t), sz)); - free(t); - return stored; -} -inline void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { @@ -230,11 +212,11 @@ inline void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &resu Temporal *t = temporal_from_wkb(wkb, input.GetSize()); free(wkb); if (!t) throw InvalidInputException("fromBinary: invalid MEOS-WKB"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } -inline void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { @@ -242,22 +224,22 @@ inline void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &r Temporal *t = temporal_from_hexwkb(hex.c_str()); if (!t) throw InvalidInputException( "fromHexWKB: invalid hex-encoded MEOS-WKB"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } -inline void TposeFromTextExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TposeFromTextExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { std::string s(input.GetData(), input.GetSize()); Temporal *t = tpose_in(s.c_str()); if (!t) throw InvalidInputException("from*: invalid input"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } -inline void TposeFromMFJSONExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TposeFromMFJSONExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { @@ -268,7 +250,7 @@ inline void TposeFromMFJSONExec(DataChunk &args, ExpressionState &, Vector &resu // binds tposeFromMFJSON to. Temporal *t = temporal_from_mfjson(s.c_str(), T_TPOSE); if (!t) throw InvalidInputException("fromMFJSON: invalid input"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } @@ -311,7 +293,6 @@ void TposeAsMfjsonExec(DataChunk &args, ExpressionState &state, Vector &result) out_data[row] = StringVector::AddString(result, json); free(json); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } // WKB output for tpose. #151 shipped the From{Binary,HexWKB,...} parsers but @@ -425,8 +406,8 @@ void TPoseTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ void TPoseTypes::RegisterCastFunctions(ExtensionLoader &loader) { - loader.RegisterCastFunction( LogicalType::VARCHAR, TPoseTypes::TPOSE(), TposeFunctions::StringToTpose); - loader.RegisterCastFunction( TPoseTypes::TPOSE(), LogicalType::VARCHAR, TposeFunctions::TposeToString); + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, TPoseTypes::TPOSE(), TposeFunctions::StringToTpose); + RegisterMeosCastFunction(loader, TPoseTypes::TPOSE(), LogicalType::VARCHAR, TposeFunctions::TposeToString); } } diff --git a/src/include/temporal/temporal_blob.hpp b/src/include/temporal/temporal_blob.hpp new file mode 100644 index 00000000..f4986c67 --- /dev/null +++ b/src/include/temporal/temporal_blob.hpp @@ -0,0 +1,18 @@ +#pragma once + +// Canonical round-trip between a DuckDB blob (string_t) and a MEOS Temporal +// value. Every type binding shares this single definition, so the +// function-pointer registrations across the bindings all resolve to one body. + +#include "meos_wrapper_simple.hpp" +#include "common.hpp" + +namespace duckdb { + +// Copy t into result's string heap and free t; returns the stored blob. +string_t TemporalToBlob(Vector &result, Temporal *t); + +// Copy the blob bytes into a freshly malloc'd Temporal* owned by the caller. +Temporal *BlobToTemporal(string_t blob); + +} // namespace duckdb diff --git a/src/mobilityduck_extension.cpp b/src/mobilityduck_extension.cpp index cf03daf9..5abf4fad 100644 --- a/src/mobilityduck_extension.cpp +++ b/src/mobilityduck_extension.cpp @@ -82,7 +82,7 @@ namespace duckdb { // 2. Utility: version scalar functions // ===================================================================== -inline void MobilityduckOpenSSLVersionScalarFun(DataChunk &args, ExpressionState &state, Vector &result) { +static void MobilityduckOpenSSLVersionScalarFun(DataChunk &args, ExpressionState &state, Vector &result) { auto &name_vector = args.data[0]; UnaryExecutor::Execute(name_vector, result, args.size(), [&](string_t name) { return StringVector::AddString( @@ -126,12 +126,12 @@ inline std::string MobilityduckFullVersion() { return out; } -inline void MobilityduckVersionScalarFun(DataChunk &args, ExpressionState &state, Vector &result) { +static void MobilityduckVersionScalarFun(DataChunk &args, ExpressionState &state, Vector &result) { const std::string s = MobilityduckShortVersion(); result.Reference(Value(s)); } -inline void MobilityduckFullVersionScalarFun(DataChunk &args, ExpressionState &state, Vector &result) { +static void MobilityduckFullVersionScalarFun(DataChunk &args, ExpressionState &state, Vector &result) { const std::string s = MobilityduckFullVersion(); result.Reference(Value(s)); } diff --git a/src/rgeo/trgeometry.cpp b/src/rgeo/trgeometry.cpp index 89ab250c..e130bcb0 100644 --- a/src/rgeo/trgeometry.cpp +++ b/src/rgeo/trgeometry.cpp @@ -76,7 +76,7 @@ LogicalType TRGeometryTypes::TRGEOMETRY() { * Constructors */ -inline void Trgeometry_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Trgeometry_constructor(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -114,12 +114,9 @@ inline void Trgeometry_constructor(DataChunk &args, ExpressionState &state, Vect return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Trgeometryinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Trgeometryinst_constructor(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &geom_vec = args.data[0]; auto &pose_vec = args.data[1]; @@ -181,13 +178,10 @@ inline void Trgeometryinst_constructor(DataChunk &args, ExpressionState &state, }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Geo_tpose_to_trgeometry(DataChunk &args, ExpressionState &state, Vector &result) { +static void Geo_tpose_to_trgeometry(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &geom_vec = args.data[0]; auto &tpose_vec = args.data[1]; @@ -238,9 +232,6 @@ inline void Geo_tpose_to_trgeometry(DataChunk &args, ExpressionState &state, Vec }); - if (count == 1){ - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } TInstant **temparr_extract_rg(Vector &trgeom_arr_vec, list_entry_t list_entry, int *count) { @@ -305,7 +296,7 @@ TInstant **temparr_extract_rg(Vector &trgeom_arr_vec, list_entry_t list_entry, i return instants; } -inline void Trgeometry_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { +static void Trgeometry_sequence_constructor(DataChunk &args, ExpressionState &state, Vector &result) { // Default values const char* default_interp = "linear"; bool default_lower_inc = true; @@ -439,9 +430,6 @@ inline void Trgeometry_sequence_constructor(DataChunk &args, ExpressionState &st } } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -451,7 +439,7 @@ inline void Trgeometry_sequence_constructor(DataChunk &args, ExpressionState &st * Conversions */ -inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -492,16 +480,13 @@ inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* * Transformations */ -inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -541,13 +526,10 @@ inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; auto &interp_vec = args.data[1]; @@ -592,13 +574,10 @@ inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom1_vec = args.data[0]; auto &tgeom2_vec = args.data[1]; @@ -646,9 +625,6 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -656,7 +632,7 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu * Accessor Functions */ -inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -683,15 +659,12 @@ inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &re return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -720,12 +693,9 @@ inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &res return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; @@ -747,9 +717,6 @@ inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r return static_cast(mem_size); }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // ---- Rigid-geometry value accessors ---- @@ -764,12 +731,12 @@ inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r // (each a freshly allocated GSERIALIZED the caller owns), per the // canonical MobilityDB SQL signatures. -inline Pose *pose_from_instant_value(const TInstant *inst) { +static Pose *pose_from_instant_value(const TInstant *inst) { Datum d = tinstant_value(inst); return reinterpret_cast(d); } -inline void Trgeometry_get_value(DataChunk &args, ExpressionState &state, Vector &result) { +static void Trgeometry_get_value(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -798,14 +765,11 @@ inline void Trgeometry_get_value(DataChunk &args, ExpressionState &state, Vector return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Trgeometry_start_value_exec(DataChunk &args, ExpressionState &state, Vector &result) { +static void Trgeometry_start_value_exec(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -832,13 +796,10 @@ inline void Trgeometry_start_value_exec(DataChunk &args, ExpressionState &state, return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Trgeometry_end_value_exec(DataChunk &args, ExpressionState &state, Vector &result) { +static void Trgeometry_end_value_exec(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -865,12 +826,9 @@ inline void Trgeometry_end_value_exec(DataChunk &args, ExpressionState &state, V return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Trgeometry_geom(DataChunk &args, ExpressionState &state, Vector &result) { +static void Trgeometry_geom(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -896,13 +854,10 @@ inline void Trgeometry_geom(DataChunk &args, ExpressionState &state, Vector &res return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -920,12 +875,9 @@ inline void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { +static void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -943,12 +895,9 @@ inline void Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector & return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Trgeometry_start_instant_exec(DataChunk &args, ExpressionState &state, Vector &result) { +static void Trgeometry_start_instant_exec(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -985,12 +934,9 @@ inline void Trgeometry_start_instant_exec(DataChunk &args, ExpressionState &stat return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Trgeometry_end_instant_exec(DataChunk &args, ExpressionState &state, Vector &result) { +static void Trgeometry_end_instant_exec(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_vec = args.data[0]; @@ -1027,15 +973,12 @@ inline void Trgeometry_end_instant_exec(DataChunk &args, ExpressionState &state, return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Trgeometry_instant_n_exec(DataChunk &args, ExpressionState &state, Vector &result) { +static void Trgeometry_instant_n_exec(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &tgeom_vec = args.data[0]; auto &n_vec = args.data[1]; @@ -1072,13 +1015,10 @@ inline void Trgeometry_instant_n_exec(DataChunk &args, ExpressionState &state, V return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { +static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -1116,9 +1056,6 @@ inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } diff --git a/src/rgeo/trgeometry_in_out.cpp b/src/rgeo/trgeometry_in_out.cpp index 3f7c1a16..2a145f6c 100644 --- a/src/rgeo/trgeometry_in_out.cpp +++ b/src/rgeo/trgeometry_in_out.cpp @@ -1,4 +1,5 @@ #include "rgeo/trgeometry.hpp" +#include "temporal/temporal_blob.hpp" #include "duckdb/main/extension/extension_loader.hpp" #include "duckdb/common/extension_type_info.hpp" #include @@ -46,7 +47,7 @@ static inline Temporal *trgeometry_parse_wkt(const char *str) { return trgeo_parse(&p, T_TRGEOMETRY); } -inline void Trgeometry_as_text_exec(DataChunk &args, ExpressionState &state, Vector &result) { +static void Trgeometry_as_text_exec(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -93,12 +94,9 @@ inline void Trgeometry_as_text_exec(DataChunk &args, ExpressionState &state, Vec } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } -inline void Trgeometry_as_ewkt_exec(DataChunk &args, ExpressionState &state, Vector &result) { +static void Trgeometry_as_ewkt_exec(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); auto &input_geom_vec = args.data[0]; @@ -147,9 +145,6 @@ inline void Trgeometry_as_ewkt_exec(DataChunk &args, ExpressionState &state, Vec } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -182,9 +177,6 @@ bool TrgeometryFunctions::StringToTrgeometry(Vector &source, Vector &result, idx return stored_data; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -226,9 +218,6 @@ bool TrgeometryFunctions::TrgeometryToString(Vector &source, Vector &result, idx return stored_result; }); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } return true; } @@ -241,15 +230,8 @@ bool TrgeometryFunctions::TrgeometryToString(Vector &source, Vector &result, idx // template rather than a tspatial_parse work-around). The result is // stored as a raw blob, the same format every other temporal type uses. -inline string_t StoreTempAsBlob(Vector &result, Temporal *t) { - size_t sz = temporal_mem_size(t); - string_t stored = StringVector::AddStringOrBlob( - result, string_t(reinterpret_cast(t), sz)); - free(t); - return stored; -} -inline void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { @@ -261,11 +243,11 @@ inline void TspatialFromWkbExec(DataChunk &args, ExpressionState &, Vector &resu Temporal *t = temporal_from_wkb(wkb, input.GetSize()); free(wkb); if (!t) throw InvalidInputException("fromBinary: invalid MEOS-WKB"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } -inline void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { @@ -273,18 +255,32 @@ inline void TspatialFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &r Temporal *t = temporal_from_hexwkb(hex.c_str()); if (!t) throw InvalidInputException( "fromHexWKB: invalid hex-encoded MEOS-WKB"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); }); } -inline void TrgeometryFromTextExec(DataChunk &args, ExpressionState &, Vector &result) { +static void TrgeometryFromTextExec(DataChunk &args, ExpressionState &, Vector &result) { UnaryExecutor::Execute( args.data[0], result, args.size(), [&](string_t input) -> string_t { std::string s(input.GetData(), input.GetSize()); Temporal *t = trgeometry_parse_wkt(s.c_str()); if (!t) throw InvalidInputException("from*: invalid input"); - return StoreTempAsBlob(result, t); + return TemporalToBlob(result, t); + }); +} + +static void TrgeometryFromMFJSONExec(DataChunk &args, ExpressionState &, Vector &result) { + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t input) -> string_t { + std::string s(input.GetData(), input.GetSize()); + // trgeometry has no dedicated *_from_mfjson symbol; route through + // the generic dispatch with the T_TRGEOMETRY temporal type, the + // same path the canonical MobilityDB SQL binds. + Temporal *t = temporal_from_mfjson(s.c_str(), T_TRGEOMETRY); + if (!t) throw InvalidInputException("fromMFJSON: invalid input"); + return TemporalToBlob(result, t); }); } @@ -332,7 +328,6 @@ void TrgeometryAsMfjsonExec(DataChunk &args, ExpressionState &state, Vector &res out_data[row] = StringVector::AddString(result, json); free(json); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TrgeometryAsWkbExec(DataChunk &args, ExpressionState &state, Vector &result, uint8_t variant) { @@ -424,6 +419,8 @@ void TRGeometryTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ ScalarFunction("trgeometryFromHexWKB", {V}, T, TspatialFromHexWkbExec)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("trgeometryFromHexEWKB", {V}, T, TspatialFromHexWkbExec)); + duckdb::RegisterSerializedScalarFunction(loader, + ScalarFunction("trgeometryFromMFJSON", {V}, T, TrgeometryFromMFJSONExec)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("trgeometryFromText", {V}, T, TrgeometryFromTextExec)); duckdb::RegisterSerializedScalarFunction(loader, @@ -432,8 +429,8 @@ void TRGeometryTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ void TRGeometryTypes::RegisterCastFunctions(ExtensionLoader &loader) { - loader.RegisterCastFunction( LogicalType::VARCHAR, TRGeometryTypes::TRGEOMETRY(), TrgeometryFunctions::StringToTrgeometry); - loader.RegisterCastFunction( TRGeometryTypes::TRGEOMETRY(), LogicalType::VARCHAR, TrgeometryFunctions::TrgeometryToString); + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, TRGeometryTypes::TRGEOMETRY(), TrgeometryFunctions::StringToTrgeometry); + RegisterMeosCastFunction(loader, TRGeometryTypes::TRGEOMETRY(), LogicalType::VARCHAR, TrgeometryFunctions::TrgeometryToString); } } diff --git a/src/single_tile_getters.cpp b/src/single_tile_getters.cpp index 5e4719fd..6530e4dd 100644 --- a/src/single_tile_getters.cpp +++ b/src/single_tile_getters.cpp @@ -85,7 +85,6 @@ void GetValueTileExec(DataChunk &args, ExpressionState &, Vector &result) { result, reinterpret_cast(tbox), sizeof(TBox)); free(tbox); } - if (count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } // ===================================================================== @@ -130,7 +129,6 @@ void GetTBoxTimeTileExec(DataChunk &args, ExpressionState &, Vector &result) { result, reinterpret_cast(tbox), sizeof(TBox)); free(tbox); } - if (count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } // ===================================================================== @@ -184,7 +182,6 @@ void GetValueTimeTileExec(DataChunk &args, ExpressionState &, Vector &result) { result, reinterpret_cast(tbox), sizeof(TBox)); free(tbox); } - if (count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } // ===================================================================== @@ -244,7 +241,6 @@ void GetSpaceTileExec(DataChunk &args, ExpressionState &, Vector &result) { result, reinterpret_cast(stbox), sizeof(STBox)); free(stbox); } - if (count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } // getStboxTimeTile(timestamptz, interval [, timestamptz='2000-01-03']) -> stbox @@ -281,7 +277,6 @@ void GetStboxTimeTileExec(DataChunk &args, ExpressionState &, Vector &result) { result, reinterpret_cast(stbox), sizeof(STBox)); free(stbox); } - if (count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } // getSpaceTimeTile(geom, t, xsize, ysize, zsize, interval @@ -338,7 +333,6 @@ void GetSpaceTimeTileExec(DataChunk &args, ExpressionState &, Vector &result) { result, reinterpret_cast(stbox), sizeof(STBox)); free(stbox); } - if (count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } // Convenience overload: getSpaceTile(geom, xsize) — uniform xyz, default origin. diff --git a/src/temporal/span_functions.cpp b/src/temporal/span_functions.cpp index 2f78bacd..b5295eaa 100644 --- a/src/temporal/span_functions.cpp +++ b/src/temporal/span_functions.cpp @@ -1138,9 +1138,6 @@ void SpanFunctions::Numspan_expand(DataChunk &args, ExpressionState &state, Vect default: throw NotImplementedException("expand(): unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpanFunctions::Tstzspan_expand(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1152,9 +1149,6 @@ void SpanFunctions::Tstzspan_expand(DataChunk &args, ExpressionState &state, Vec [&](string_t blob, interval_t value) -> string_t { return Tstzspan_expand_common(blob, value, result); }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } static inline string_t Numspan_shift_common(const string_t &blob, Datum shift_datum, @@ -1255,9 +1249,6 @@ void SpanFunctions::Tstzspan_shift(DataChunk &args, ExpressionState &state, Vect [&](string_t blob, interval_t shift_interval) -> string_t { return Tstzspan_shift_common(blob, shift_interval, result); }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } static inline string_t Numspan_scale_common(const string_t &blob, Datum scale_datum, @@ -1357,9 +1348,6 @@ void SpanFunctions::Tstzspan_scale(DataChunk &args, ExpressionState &state, Vect [&](string_t blob, interval_t scale_interval) -> string_t { return Tstzspan_scale_common(blob, scale_interval, result); }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } static inline string_t Tstzspan_shift_scale_common(const string_t &blob, interval_t shift_iv, interval_t scale_iv, @@ -1462,9 +1450,6 @@ void SpanFunctions::Numspan_shift_scale(DataChunk &args, ExpressionState &state, default: throw NotImplementedException("shiftScale(): unsupported span type for this overload"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpanFunctions::Tstzspan_shift_scale(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1474,9 +1459,6 @@ void SpanFunctions::Tstzspan_shift_scale(DataChunk &args, ExpressionState &state [&](string_t blob, interval_t shift, interval_t scale) -> string_t { return Tstzspan_shift_scale_common(blob, shift, scale, result); }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpanFunctions::Floatspan_floor(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1538,9 +1520,6 @@ void SpanFunctions::Float_round(DataChunk &args, ExpressionState &state, Vector return float_round(float_value, 0); }); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpanFunctions::Floatspan_round(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1676,9 +1655,6 @@ void SpanFunctions::Span_eq(DataChunk &args, ExpressionState &state, Vector &res return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span <> span --- void SpanFunctions::Span_ne(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1706,9 +1682,6 @@ void SpanFunctions::Span_ne(DataChunk &args, ExpressionState &state, Vector &res return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span < span --- void SpanFunctions::Span_lt(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1736,9 +1709,6 @@ void SpanFunctions::Span_lt(DataChunk &args, ExpressionState &state, Vector &res return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span <= span --- void SpanFunctions::Span_le(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1766,9 +1736,6 @@ void SpanFunctions::Span_le(DataChunk &args, ExpressionState &state, Vector &res return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpanFunctions::Span_gt(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1796,9 +1763,6 @@ void SpanFunctions::Span_gt(DataChunk &args, ExpressionState &state, Vector &res return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span >= span --- void SpanFunctions::Span_ge(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1826,9 +1790,6 @@ void SpanFunctions::Span_ge(DataChunk &args, ExpressionState &state, Vector &res return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpanFunctions::Span_cmp(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1856,9 +1817,6 @@ void SpanFunctions::Span_cmp(DataChunk &args, ExpressionState &state, Vector &re return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span @> value --- void SpanFunctions::Contains_span_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2000,9 +1958,6 @@ void SpanFunctions::Contains_span_span(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -2113,9 +2068,6 @@ void SpanFunctions::Contained_value_span(DataChunk &args, ExpressionState &state default: throw NotImplementedException("value <@ SPAN: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span <@ span --- @@ -2150,9 +2102,6 @@ void SpanFunctions::Contained_span_span(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span && span --- @@ -2186,9 +2135,6 @@ void SpanFunctions::Overlaps_span_span(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: value -|- span--- @@ -2298,9 +2244,6 @@ void SpanFunctions::Adjacent_value_span(DataChunk &args, ExpressionState &state, default: throw NotImplementedException("value -|- SPAN: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span -|- value --- @@ -2410,9 +2353,6 @@ void SpanFunctions::Adjacent_span_value(DataChunk &args, ExpressionState &state, default: throw NotImplementedException("SPAN -|- value: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span -|- span --- @@ -2444,9 +2384,6 @@ void SpanFunctions::Adjacent_span_span(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- POSITION OPERATORS --- @@ -2558,9 +2495,6 @@ void SpanFunctions::Left_value_span(DataChunk &args, ExpressionState &state, Vec default: throw NotImplementedException("value << SPAN: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span << value --- void SpanFunctions::Left_span_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2669,9 +2603,6 @@ void SpanFunctions::Left_span_value(DataChunk &args, ExpressionState &state, Vec default: throw NotImplementedException("SPAN << value: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span << span --- void SpanFunctions::Left_span_span(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2702,9 +2633,6 @@ void SpanFunctions::Left_span_span(DataChunk &args, ExpressionState &state, Vect return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: value >> span --- void SpanFunctions::Right_value_span(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2813,9 +2741,6 @@ void SpanFunctions::Right_value_span(DataChunk &args, ExpressionState &state, Ve default: throw NotImplementedException("value >> SPAN: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span >> value --- void SpanFunctions::Right_span_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2923,9 +2848,6 @@ void SpanFunctions::Right_span_value(DataChunk &args, ExpressionState &state, Ve default: throw NotImplementedException("SPAN >> value: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span >> span --- void SpanFunctions::Right_span_span(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2956,9 +2878,6 @@ void SpanFunctions::Right_span_span(DataChunk &args, ExpressionState &state, Vec return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // ---OPERATOR: value &< span --- @@ -3068,9 +2987,6 @@ void SpanFunctions::Overleft_value_span(DataChunk &args, ExpressionState &state, default: throw NotImplementedException("value &< SPAN: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // ---OPERATOR: span &< value --- void SpanFunctions::Overleft_span_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3178,9 +3094,6 @@ void SpanFunctions::Overleft_span_value(DataChunk &args, ExpressionState &state, default: throw NotImplementedException("SPAN &< value: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // ---OPERATOR: span &< span --- @@ -3212,9 +3125,6 @@ void SpanFunctions::Overleft_span_span(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: value &> span --- @@ -3323,9 +3233,6 @@ void SpanFunctions::Overright_value_span(DataChunk &args, ExpressionState &state default: throw NotImplementedException("value &> SPAN: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span &> value --- @@ -3434,9 +3341,6 @@ void SpanFunctions::Overright_span_value(DataChunk &args, ExpressionState &state default: throw NotImplementedException("SPAN &> value: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span &> span --- @@ -3468,9 +3372,6 @@ void SpanFunctions::Overright_span_span(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- SET OPERATOR --- @@ -3613,9 +3514,6 @@ void SpanFunctions::Union_value_span(DataChunk &args, ExpressionState &state, Ve default: throw NotImplementedException("value + SPAN: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } } @@ -3758,9 +3656,6 @@ void SpanFunctions::Union_span_value(DataChunk &args, ExpressionState &state, Ve default: throw NotImplementedException("SPAN + value: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } } @@ -3795,9 +3690,6 @@ void SpanFunctions::Union_span_span(DataChunk &args, ExpressionState &state, Vec return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: INTERSECTION --- void SpanFunctions::Intersection_value_span(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3960,9 +3852,6 @@ void SpanFunctions::Intersection_value_span(DataChunk &args, ExpressionState &st default: throw NotImplementedException("value * SPAN: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpanFunctions::Intersection_span_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4125,9 +4014,6 @@ void SpanFunctions::Intersection_span_value(DataChunk &args, ExpressionState &st default: throw NotImplementedException("SPAN * value: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpanFunctions::Intersection_span_span(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4174,9 +4060,6 @@ void SpanFunctions::Intersection_span_span(DataChunk &args, ExpressionState &sta return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: MINUS --- @@ -4340,9 +4223,6 @@ void SpanFunctions::Minus_value_span(DataChunk &args, ExpressionState &state, Ve default: throw NotImplementedException("value - SPAN: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpanFunctions::Minus_span_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4504,9 +4384,6 @@ void SpanFunctions::Minus_span_value(DataChunk &args, ExpressionState &state, Ve default: throw NotImplementedException("SPAN - value: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } } @@ -4554,9 +4431,6 @@ void SpanFunctions::Minus_span_span(DataChunk &args, ExpressionState &state, Vec return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } //--- DISTANCE FUNCTIONS --- @@ -4666,9 +4540,6 @@ void SpanFunctions::Distance_span_value(DataChunk &args, ExpressionState &state, throw NotImplementedException("distance between SPAN and value: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpanFunctions::Distance_value_span(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4776,9 +4647,6 @@ void SpanFunctions::Distance_value_span(DataChunk &args, ExpressionState &state, default: throw NotImplementedException("distance between value and SPAN: unsupported span type"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpanFunctions::Distance_span_span(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4830,9 +4698,6 @@ void SpanFunctions::Distance_span_span(DataChunk &args, ExpressionState &state, } ); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } } diff --git a/src/temporal/spanset_functions.cpp b/src/temporal/spanset_functions.cpp index 5c88b75c..f5a7da86 100644 --- a/src/temporal/spanset_functions.cpp +++ b/src/temporal/spanset_functions.cpp @@ -1256,9 +1256,6 @@ void SpansetFunctions::Tstzspanset_shift(DataChunk &args, ExpressionState &state [&](string_t blob, interval_t shift_interval) -> string_t { return Tstzspanset_shift_common(blob, shift_interval, result); }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } static inline string_t Numspanset_scale_common(const string_t &blob, Datum scale_datum, @@ -1357,9 +1354,6 @@ void SpansetFunctions::Tstzspanset_scale(DataChunk &args, ExpressionState &state [&](string_t blob, interval_t scale_interval) -> string_t { return Tstzspanset_scale_common(blob, scale_interval, result); }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } static inline string_t Tstzspanset_shift_scale_common(const string_t &blob, interval_t shift_iv, interval_t scale_iv, @@ -1462,9 +1456,6 @@ void SpansetFunctions::Numspanset_shift_scale(DataChunk &args, ExpressionState & default: throw NotImplementedException("shiftScale(): unsupported spanset type for this overload"); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpansetFunctions::Tstzspanset_shift_scale(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1474,9 +1465,6 @@ void SpansetFunctions::Tstzspanset_shift_scale(DataChunk &args, ExpressionState [&](string_t blob, interval_t shift, interval_t scale) -> string_t { return Tstzspanset_shift_scale_common(blob, shift, scale, result); }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpansetFunctions::Floatspanset_floor(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1805,9 +1793,6 @@ void SpansetFunctions::Spanset_eq(DataChunk &args, ExpressionState &state, Vecto return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: spanset <> spanset --- void SpansetFunctions::Spanset_ne(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1835,9 +1820,6 @@ void SpansetFunctions::Spanset_ne(DataChunk &args, ExpressionState &state, Vecto return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: spanset < spanset --- void SpansetFunctions::Spanset_lt(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1865,9 +1847,6 @@ void SpansetFunctions::Spanset_lt(DataChunk &args, ExpressionState &state, Vecto return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: spanset <= spanset--- void SpansetFunctions::Spanset_le(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1895,9 +1874,6 @@ void SpansetFunctions::Spanset_le(DataChunk &args, ExpressionState &state, Vecto return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpansetFunctions::Spanset_gt(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1925,9 +1901,6 @@ void SpansetFunctions::Spanset_gt(DataChunk &args, ExpressionState &state, Vecto return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // --- OPERATOR: span >= span --- void SpansetFunctions::Spanset_ge(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1955,9 +1928,6 @@ void SpansetFunctions::Spanset_ge(DataChunk &args, ExpressionState &state, Vecto return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void SpansetFunctions::Spanset_cmp(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1985,9 +1955,6 @@ void SpansetFunctions::Spanset_cmp(DataChunk &args, ExpressionState &state, Vect return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } } // namespace duckdb diff --git a/src/temporal/tbox_functions.cpp b/src/temporal/tbox_functions.cpp index 7507bc61..9b07a463 100644 --- a/src/temporal/tbox_functions.cpp +++ b/src/temporal/tbox_functions.cpp @@ -105,9 +105,6 @@ void TboxFunctions::NumberTimestamptzToTboxExecutor(Vector &value, Vector &t, Me return MallocBlobToResult(result, tbox_data, tbox_size); } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Number_timestamptz_to_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -144,9 +141,6 @@ void TboxFunctions::Numspan_timestamptz_to_tbox(DataChunk &args, ExpressionState return MallocBlobToResult(result, tbox_data, tbox_size); } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } template @@ -179,9 +173,6 @@ void TboxFunctions::NumberTstzspanToTboxExecutor(Vector &value, Vector &span_str return MallocBlobToResult(result, tbox_data, tbox_size); } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Number_tstzspan_to_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -228,9 +219,6 @@ void TboxFunctions::Numspan_tstzspan_to_tbox(DataChunk &args, ExpressionState &s return MallocBlobToResult(result, tbox_data, tbox_size); } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } template @@ -254,9 +242,6 @@ void TboxFunctions::NumberToTboxExecutor(Vector &value, MeosType basetype, Vecto return MallocBlobToResult(result, tbox_data, tbox_size); } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Number_to_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -297,9 +282,6 @@ void TboxFunctions::TimestamptzToTboxExecutor(Vector &value, Vector &result, idx return MallocBlobToResult(result, tbox_data, tbox_size); } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Timestamptz_to_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -332,9 +314,6 @@ void TboxFunctions::SetToTboxExecutor(Vector &value, Vector &result, idx_t count return MallocBlobToResult(result, tbox_data, tbox_size); } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Set_to_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -367,9 +346,6 @@ void TboxFunctions::SpanToTboxExecutor(Vector &value, Vector &result, idx_t coun return MallocBlobToResult(result, tbox_data, tbox_size); } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Span_to_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -402,9 +378,6 @@ void TboxFunctions::TboxToIntspanExecutor(Vector &value, Vector &result, idx_t c return MallocBlobToResult(result, span_data, span_size); } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_to_intspan(DataChunk &args, ExpressionState &state, Vector &result) { @@ -437,9 +410,6 @@ void TboxFunctions::TboxToFloatspanExecutor(Vector &value, Vector &result, idx_t return MallocBlobToResult(result, span_data, span_size); } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_to_floatspan(DataChunk &args, ExpressionState &state, Vector &result) { @@ -472,9 +442,6 @@ void TboxFunctions::TboxToTstzspanExecutor(Vector &value, Vector &result, idx_t return MallocBlobToResult(result, span_data, span_size); } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { @@ -507,9 +474,6 @@ void TboxFunctions::SpansetToTboxExecutor(Vector &value, Vector &result, idx_t c return MallocBlobToResult(result, tbox_data, tbox_size); } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Spanset_to_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -538,9 +502,6 @@ void TboxFunctions::Tbox_hasx(DataChunk &args, ExpressionState &state, Vector &r return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_hast(DataChunk &args, ExpressionState &state, Vector &result) { @@ -560,9 +521,6 @@ void TboxFunctions::Tbox_hast(DataChunk &args, ExpressionState &state, Vector &r return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_xmin(DataChunk &args, ExpressionState &state, Vector &result) { @@ -587,9 +545,6 @@ void TboxFunctions::Tbox_xmin(DataChunk &args, ExpressionState &state, Vector &r return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_xmin_inc(DataChunk &args, ExpressionState &state, Vector &result) { @@ -614,9 +569,6 @@ void TboxFunctions::Tbox_xmin_inc(DataChunk &args, ExpressionState &state, Vecto return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_xmax(DataChunk &args, ExpressionState &state, Vector &result) { @@ -641,9 +593,6 @@ void TboxFunctions::Tbox_xmax(DataChunk &args, ExpressionState &state, Vector &r return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_xmax_inc(DataChunk &args, ExpressionState &state, Vector &result) { @@ -668,9 +617,6 @@ void TboxFunctions::Tbox_xmax_inc(DataChunk &args, ExpressionState &state, Vecto return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_tmin(DataChunk &args, ExpressionState &state, Vector &result) { @@ -696,9 +642,6 @@ void TboxFunctions::Tbox_tmin(DataChunk &args, ExpressionState &state, Vector &r return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_tmin_inc(DataChunk &args, ExpressionState &state, Vector &result) { @@ -723,9 +666,6 @@ void TboxFunctions::Tbox_tmin_inc(DataChunk &args, ExpressionState &state, Vecto return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_tmax(DataChunk &args, ExpressionState &state, Vector &result) { @@ -751,9 +691,6 @@ void TboxFunctions::Tbox_tmax(DataChunk &args, ExpressionState &state, Vector &r return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_tmax_inc(DataChunk &args, ExpressionState &state, Vector &result) { @@ -778,9 +715,6 @@ void TboxFunctions::Tbox_tmax_inc(DataChunk &args, ExpressionState &state, Vecto return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } template @@ -813,9 +747,6 @@ void TboxFunctions::TboxShiftValueExecutor(Vector &tbox, Vector &shift, LogicalT return MallocBlobToResult(result, shifted_tbox_data, shifted_tbox_size); } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_shift_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -851,9 +782,6 @@ void TboxFunctions::Tbox_shift_time(DataChunk &args, ExpressionState &state, Vec return MallocBlobToResult(result, shifted_tbox_data, shifted_tbox_size); } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } template @@ -886,9 +814,6 @@ void TboxFunctions::TboxScaleValueExecutor(Vector &tbox, Vector &width, LogicalT return MallocBlobToResult(result, scaled_tbox_data, scaled_tbox_size); } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_scale_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -924,9 +849,6 @@ void TboxFunctions::Tbox_scale_time(DataChunk &args, ExpressionState &state, Vec return MallocBlobToResult(result, scaled_tbox_data, scaled_tbox_size); } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } template @@ -962,9 +884,6 @@ void TboxFunctions::TboxShiftScaleValueExecutor(Vector &tbox, Vector &shift, Vec return MallocBlobToResult(result, shifted_scaled_tbox_data, shifted_scaled_tbox_size); } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_shift_scale_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1001,9 +920,6 @@ void TboxFunctions::Tbox_shift_scale_time(DataChunk &args, ExpressionState &stat return MallocBlobToResult(result, shifted_scaled_tbox_data, shifted_scaled_tbox_size); } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } template @@ -1041,9 +957,6 @@ void TboxFunctions::TboxExpandValueExecutor(Vector &tbox, Vector &value, MeosTyp return MallocBlobToResult(result, ret_data, ret_size); } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_expand_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1084,9 +997,6 @@ void TboxFunctions::Tbox_expand_time(DataChunk &args, ExpressionState &state, Ve return MallocBlobToResult(result, ret_data, ret_size); } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_round(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1133,9 +1043,6 @@ void TboxFunctions::Tbox_round(DataChunk &args, ExpressionState &state, Vector & } ); } - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Contains_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1165,9 +1072,6 @@ void TboxFunctions::Contains_tbox_tbox(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Contained_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1197,9 +1101,6 @@ void TboxFunctions::Contained_tbox_tbox(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Overlaps_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1229,9 +1130,6 @@ void TboxFunctions::Overlaps_tbox_tbox(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Adjacent_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1261,9 +1159,6 @@ void TboxFunctions::Adjacent_tbox_tbox(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Same_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1293,9 +1188,6 @@ void TboxFunctions::Same_tbox_tbox(DataChunk &args, ExpressionState &state, Vect return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Left_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1325,9 +1217,6 @@ void TboxFunctions::Left_tbox_tbox(DataChunk &args, ExpressionState &state, Vect return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Overleft_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1357,9 +1246,6 @@ void TboxFunctions::Overleft_tbox_tbox(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Right_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1389,9 +1275,6 @@ void TboxFunctions::Right_tbox_tbox(DataChunk &args, ExpressionState &state, Vec return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Overright_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1421,9 +1304,6 @@ void TboxFunctions::Overright_tbox_tbox(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Before_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1453,9 +1333,6 @@ void TboxFunctions::Before_tbox_tbox(DataChunk &args, ExpressionState &state, Ve return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Overbefore_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1485,9 +1362,6 @@ void TboxFunctions::Overbefore_tbox_tbox(DataChunk &args, ExpressionState &state return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::After_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1517,9 +1391,6 @@ void TboxFunctions::After_tbox_tbox(DataChunk &args, ExpressionState &state, Vec return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Overafter_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1549,9 +1420,6 @@ void TboxFunctions::Overafter_tbox_tbox(DataChunk &args, ExpressionState &state, return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Union_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1590,9 +1458,6 @@ void TboxFunctions::Union_tbox_tbox(DataChunk &args, ExpressionState &state, Vec return MallocBlobToResult(result, ret_data, ret_size); } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Intersection_tbox_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1631,9 +1496,6 @@ void TboxFunctions::Intersection_tbox_tbox(DataChunk &args, ExpressionState &sta return MallocBlobToResult(result, ret_data, ret_size); } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } // Comparison operators @@ -1664,9 +1526,6 @@ void TboxFunctions::Tbox_eq(DataChunk &args, ExpressionState &state, Vector &res return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_ne(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1696,9 +1555,6 @@ void TboxFunctions::Tbox_ne(DataChunk &args, ExpressionState &state, Vector &res return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_lt(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1728,9 +1584,6 @@ void TboxFunctions::Tbox_lt(DataChunk &args, ExpressionState &state, Vector &res return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_le(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1760,9 +1613,6 @@ void TboxFunctions::Tbox_le(DataChunk &args, ExpressionState &state, Vector &res return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_gt(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1792,9 +1642,6 @@ void TboxFunctions::Tbox_gt(DataChunk &args, ExpressionState &state, Vector &res return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_ge(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1824,9 +1671,6 @@ void TboxFunctions::Tbox_ge(DataChunk &args, ExpressionState &state, Vector &res return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_cmp(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1856,9 +1700,6 @@ void TboxFunctions::Tbox_cmp(DataChunk &args, ExpressionState &state, Vector &re return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -1888,9 +1729,6 @@ void TboxFunctions::Tbox_as_wkb(DataChunk &args, ExpressionState &state, Vector return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_as_hexwkb(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1915,9 +1753,6 @@ void TboxFunctions::Tbox_as_hexwkb(DataChunk &args, ExpressionState &state, Vect return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_from_wkb(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1944,9 +1779,6 @@ void TboxFunctions::Tbox_from_wkb(DataChunk &args, ExpressionState &state, Vecto return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_from_hexwkb(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1968,9 +1800,6 @@ void TboxFunctions::Tbox_from_hexwkb(DataChunk &args, ExpressionState &state, Ve return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_hash(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1988,9 +1817,6 @@ void TboxFunctions::Tbox_hash(DataChunk &args, ExpressionState &state, Vector &r return static_cast(h); } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TboxFunctions::Tbox_hash_extended(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2008,9 +1834,6 @@ void TboxFunctions::Tbox_hash_extended(DataChunk &args, ExpressionState &state, return static_cast(h); } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } } // namespace duckdb diff --git a/src/temporal/temporal.cpp b/src/temporal/temporal.cpp index e154afc0..4723a3e0 100644 --- a/src/temporal/temporal.cpp +++ b/src/temporal/temporal.cpp @@ -2241,7 +2241,7 @@ void GetBinDateExec(DataChunk &args, ExpressionState &, Vector &result) { // ----- tbox tile emitters: LIST(TBOX) outputs ----- -inline void EmitTboxList(Vector &result, idx_t row_idx, TBox *tiles, int count, +static void EmitTboxList(Vector &result, idx_t row_idx, TBox *tiles, int count, idx_t &total_offset, list_entry_t *list_entries, Vector &child_vector, ValidityMask &result_validity) { if (!tiles || count <= 0) { diff --git a/src/temporal/temporal_aggregates.cpp b/src/temporal/temporal_aggregates.cpp index 2053b098..8b5a0d3b 100644 --- a/src/temporal/temporal_aggregates.cpp +++ b/src/temporal/temporal_aggregates.cpp @@ -664,7 +664,7 @@ struct SpanSetState { }; template -inline void SpanSetCombine(STATE &source, STATE &target) { +static void SpanSetCombine(STATE &source, STATE &target) { if (!source.value) return; if (!target.value) { target.value = source.value; @@ -681,7 +681,7 @@ inline void SpanSetCombine(STATE &source, STATE &target) { } template -inline void SpanSetFinalize(STATE &state, T &target, AggregateFinalizeData &fd) { +static void SpanSetFinalize(STATE &state, T &target, AggregateFinalizeData &fd) { if (!state.value) { fd.ReturnNull(); return; } // spanset_union_finalfn frees the state internally on the success // path, so clear the pointer first to prevent Destroy from @@ -695,7 +695,7 @@ inline void SpanSetFinalize(STATE &state, T &target, AggregateFinalizeData &fd) } template -inline void SpanSetDestroy(STATE &state) { +static void SpanSetDestroy(STATE &state) { if (state.value) { free(state.value); state.value = nullptr; @@ -773,7 +773,7 @@ struct SetAggState { }; template -inline void SetCombine(STATE &source, STATE &target) { +static void SetCombine(STATE &source, STATE &target) { if (!source.value) return; if (!target.value) { target.value = source.value; @@ -788,7 +788,7 @@ inline void SetCombine(STATE &source, STATE &target) { } template -inline void SetFinalize(STATE &state, T &target, AggregateFinalizeData &fd) { +static void SetFinalize(STATE &state, T &target, AggregateFinalizeData &fd) { if (!state.value) { fd.ReturnNull(); return; } // set_union_finalfn frees the state internally on the success path. Set *result = set_union_finalfn(state.value); @@ -800,7 +800,7 @@ inline void SetFinalize(STATE &state, T &target, AggregateFinalizeData &fd) { } template -inline void SetDestroy(STATE &state) { +static void SetDestroy(STATE &state) { if (state.value) { free(state.value); state.value = nullptr; diff --git a/src/temporal/temporal_blob.cpp b/src/temporal/temporal_blob.cpp new file mode 100644 index 00000000..773cae21 --- /dev/null +++ b/src/temporal/temporal_blob.cpp @@ -0,0 +1,26 @@ +// Single definition of the canonical DuckDB-blob <-> MEOS Temporal round-trip +// shared by every type binding. + +#include "temporal/temporal_blob.hpp" + +#include +#include + +namespace duckdb { + +string_t TemporalToBlob(Vector &result, Temporal *t) { + size_t sz = temporal_mem_size(t); + string_t out = StringVector::AddStringOrBlob( + result, reinterpret_cast(t), sz); + free(t); + return out; +} + +Temporal *BlobToTemporal(string_t blob) { + size_t sz = blob.GetSize(); + uint8_t *copy = static_cast(malloc(sz)); + memcpy(copy, blob.GetData(), sz); + return reinterpret_cast(copy); +} + +} // namespace duckdb diff --git a/src/temporal/temporal_functions.cpp b/src/temporal/temporal_functions.cpp index fc8a2b68..c5f7b118 100644 --- a/src/temporal/temporal_functions.cpp +++ b/src/temporal/temporal_functions.cpp @@ -1,6 +1,7 @@ #include "meos_wrapper_simple.hpp" #include "common.hpp" #include "temporal/temporal_functions.hpp" +#include "temporal/temporal_blob.hpp" #include "temporal/spanset.hpp" #include "geo_util.hpp" @@ -186,9 +187,6 @@ void TemporalFunctions::Tinstant_constructor_common(Vector &value, Vector &ts, V return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tinstant_constructor_text(Vector &value, Vector &ts, Vector &result, idx_t count) { @@ -214,9 +212,6 @@ void TemporalFunctions::Tinstant_constructor_text(Vector &value, Vector &ts, Vec return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tinstant_constructor(DataChunk &args, ExpressionState &state, Vector &result) { @@ -339,9 +334,6 @@ void TemporalFunctions::Tsequence_constructor(DataChunk &args, ExpressionState & return stored_data; } ); - if (row_count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tsequenceset_constructor(DataChunk &args, ExpressionState &state, Vector &result) { @@ -405,9 +397,6 @@ void TemporalFunctions::Tsequenceset_constructor(DataChunk &args, ExpressionStat return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } static string_t Tsequence_from_base_tstzset_impl(Datum datum, string_t set_blob, MeosType temptype, Vector &result) { @@ -480,9 +469,6 @@ void TemporalFunctions::Tsequence_from_base_tstzset(DataChunk &args, ExpressionS throw InvalidInputException("Invalid argument type for Tsequence_from_base_tstzset: " + arg_type.ToString()); } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } static string_t Tsequence_from_base_tstzspan_impl(Datum datum, string_t span_blob, MeosType temptype, interpType interp, Vector &result) { @@ -563,9 +549,6 @@ void TemporalFunctions::Tsequence_from_base_tstzspan(DataChunk &args, Expression throw InvalidInputException("Invalid argument type for Tsequence_from_base_tstzspan: " + arg_type.ToString()); } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } static string_t Tsequenceset_from_base_tstzspanset_impl(Datum datum, string_t spanset_blob, MeosType temptype, interpType interp, Vector &result) { @@ -646,9 +629,6 @@ void TemporalFunctions::Tsequenceset_from_base_tstzspanset(DataChunk &args, Expr throw InvalidInputException("Invalid argument type for Tsequenceset_from_base_tstzspanset: " + arg_type.ToString()); } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** * Conversion functions: [TYPE] -> Temporal @@ -684,9 +664,6 @@ void TemporalFunctions::Temporal_to_tstzspan(DataChunk &args, ExpressionState &s return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tnumber_to_span(DataChunk &args, ExpressionState &state, Vector &result) { @@ -718,9 +695,6 @@ void TemporalFunctions::Tnumber_to_span(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } static string_t Tbool_to_tint_common(string_t input, Vector &result) { @@ -927,9 +901,6 @@ void TemporalFunctions::Tnumber_to_tbox(DataChunk &args, ExpressionState &state, } else { throw InvalidInputException("Invalid argument type for Tnumber_to_tbox: " + arg_type.ToString()); } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } bool TemporalFunctions::Tnumber_to_tbox_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { @@ -973,9 +944,6 @@ void TemporalFunctions::Temporal_enforce_typmod(DataChunk &args, ExpressionState return StringVector::AddStringOrBlob(result, input); } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } bool TemporalFunctions::Temporal_enforce_typmod_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { @@ -1020,9 +988,6 @@ void TemporalFunctions::Temporal_subtype(DataChunk &args, ExpressionState &state return string_t(str); } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_interp(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1046,9 +1011,6 @@ void TemporalFunctions::Temporal_interp(DataChunk &args, ExpressionState &state, return string_t(str); } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1072,9 +1034,6 @@ void TemporalFunctions::Temporal_mem_size(DataChunk &args, ExpressionState &stat return (int32_t)mem_size; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tinstant_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1098,9 +1057,6 @@ void TemporalFunctions::Tinstant_value(DataChunk &args, ExpressionState &state, return (int64_t)ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_valueset(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1132,9 +1088,6 @@ void TemporalFunctions::Temporal_valueset(DataChunk &args, ExpressionState &stat return blob; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_start_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1158,9 +1111,6 @@ void TemporalFunctions::Temporal_start_value(DataChunk &args, ExpressionState &s return (int64_t)ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_end_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1184,9 +1134,6 @@ void TemporalFunctions::Temporal_end_value(DataChunk &args, ExpressionState &sta return (int64_t)ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_min_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1210,9 +1157,6 @@ void TemporalFunctions::Temporal_min_value(DataChunk &args, ExpressionState &sta return (int64_t)ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_max_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1236,9 +1180,6 @@ void TemporalFunctions::Temporal_max_value(DataChunk &args, ExpressionState &sta return (int64_t)ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_value_n(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1363,9 +1304,6 @@ void TemporalFunctions::Temporal_value_n(DataChunk &args, ExpressionState &state ); } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_num_instants(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1389,9 +1327,6 @@ void TemporalFunctions::Temporal_num_instants(DataChunk &args, ExpressionState & return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_min_instant(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1423,9 +1358,6 @@ void TemporalFunctions::Temporal_min_instant(DataChunk &args, ExpressionState &s return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_max_instant(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1457,9 +1389,6 @@ void TemporalFunctions::Temporal_max_instant(DataChunk &args, ExpressionState &s return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1484,9 +1413,6 @@ void TemporalFunctions::Tinstant_timestamptz(DataChunk &args, ExpressionState &s return duckdb_ts; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_time(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1518,9 +1444,6 @@ void TemporalFunctions::Temporal_time(DataChunk &args, ExpressionState &state, V return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_duration(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1554,9 +1477,6 @@ void TemporalFunctions::Temporal_duration(DataChunk &args, ExpressionState &stat return duckdb_interval; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_sequences(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1628,9 +1548,6 @@ void TemporalFunctions::Temporal_start_timestamptz(DataChunk &args, ExpressionSt return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_end_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1655,9 +1572,6 @@ void TemporalFunctions::Temporal_end_timestamptz(DataChunk &args, ExpressionStat return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_timestamps(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1770,9 +1684,6 @@ void TemporalFunctions::Temporal_num_sequences(DataChunk &args, ExpressionState return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1796,9 +1707,6 @@ void TemporalFunctions::Temporal_lower_inc(DataChunk &args, ExpressionState &sta return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_upper_inc(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1822,9 +1730,6 @@ void TemporalFunctions::Temporal_upper_inc(DataChunk &args, ExpressionState &sta return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_start_instant(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1855,9 +1760,6 @@ void TemporalFunctions::Temporal_start_instant(DataChunk &args, ExpressionState return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_end_instant(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1888,9 +1790,6 @@ void TemporalFunctions::Temporal_end_instant(DataChunk &args, ExpressionState &s return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_instant_n(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1921,9 +1820,6 @@ void TemporalFunctions::Temporal_instant_n(DataChunk &args, ExpressionState &sta return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_num_timestamps(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1947,9 +1843,6 @@ void TemporalFunctions::Temporal_num_timestamps(DataChunk &args, ExpressionState return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -1980,9 +1873,6 @@ void TemporalFunctions::Temporal_timestamptz_n(DataChunk &args, ExpressionState return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_start_sequence(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2013,9 +1903,6 @@ void TemporalFunctions::Temporal_start_sequence(DataChunk &args, ExpressionState return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -2047,9 +1934,6 @@ void TemporalFunctions::Temporal_end_sequence(DataChunk &args, ExpressionState & return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_sequence_n(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2080,9 +1964,6 @@ void TemporalFunctions::Temporal_sequence_n(DataChunk &args, ExpressionState &st return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_segments(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2168,9 +2049,6 @@ void TemporalFunctions::Temporal_shift_time(DataChunk &args, ExpressionState &st return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_scale_time(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2204,9 +2082,6 @@ void TemporalFunctions::Temporal_scale_time(DataChunk &args, ExpressionState &st return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_shift_scale_time(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2240,9 +2115,6 @@ void TemporalFunctions::Temporal_shift_scale_time(DataChunk &args, ExpressionSta return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -2282,9 +2154,6 @@ void TemporalFunctions::Temporal_to_tinstant(DataChunk &args, ExpressionState &s return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_to_tsequence(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2324,9 +2193,6 @@ void TemporalFunctions::Temporal_to_tsequence(DataChunk &args, ExpressionState & return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_to_tsequenceset(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2366,9 +2232,6 @@ void TemporalFunctions::Temporal_to_tsequenceset(DataChunk &args, ExpressionStat return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2409,9 +2272,6 @@ void TemporalFunctions::Temporal_set_interp(DataChunk &args, ExpressionState &st return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_append_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2464,9 +2324,6 @@ void TemporalFunctions::Temporal_append_tinstant(DataChunk &args, ExpressionStat return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_append_tsequence(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2510,9 +2367,6 @@ void TemporalFunctions::Temporal_append_tsequence(DataChunk &args, ExpressionSta return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_merge(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2553,9 +2407,6 @@ void TemporalFunctions::Temporal_merge(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_merge_array(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2609,9 +2460,6 @@ void TemporalFunctions::Temporal_merge_array(DataChunk &args, ExpressionState &s return stored_data; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tnumber_shift_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2643,9 +2491,6 @@ void TemporalFunctions::Tnumber_shift_value(DataChunk &args, ExpressionState &st return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tnumber_scale_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2677,9 +2522,6 @@ void TemporalFunctions::Tnumber_scale_value(DataChunk &args, ExpressionState &st return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tnumber_shift_scale_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2711,9 +2553,6 @@ void TemporalFunctions::Tnumber_shift_scale_value(DataChunk &args, ExpressionSta return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -2820,9 +2659,6 @@ static void temporal_at_minus_values_dispatch(DataChunk &args, ExpressionState & throw InvalidInputException("Invalid argument type for atValues/minusValues: " + val_type.ToString()); } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_at_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2873,9 +2709,6 @@ void TemporalFunctions::Temporal_at_timestamptz(DataChunk &args, ExpressionState return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_at_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2925,9 +2758,6 @@ void TemporalFunctions::Temporal_at_tstzspan(DataChunk &args, ExpressionState &s return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_at_tstzspanset(DataChunk &args, ExpressionState &state, Vector &result) { @@ -2977,9 +2807,6 @@ void TemporalFunctions::Temporal_at_tstzspanset(DataChunk &args, ExpressionState return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tnumber_at_span(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3029,9 +2856,6 @@ void TemporalFunctions::Tnumber_at_span(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_at_min(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3069,9 +2893,6 @@ void TemporalFunctions::Temporal_at_min(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_minus_min(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3100,9 +2921,6 @@ void TemporalFunctions::Temporal_minus_min(DataChunk &args, ExpressionState &sta return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_at_max(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3131,9 +2949,6 @@ void TemporalFunctions::Temporal_at_max(DataChunk &args, ExpressionState &state, return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_minus_max(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3162,9 +2977,6 @@ void TemporalFunctions::Temporal_minus_max(DataChunk &args, ExpressionState &sta return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tnumber_minus_span(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3205,9 +3017,6 @@ void TemporalFunctions::Tnumber_minus_span(DataChunk &args, ExpressionState &sta return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tnumber_at_spanset(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3248,9 +3057,6 @@ void TemporalFunctions::Tnumber_at_spanset(DataChunk &args, ExpressionState &sta return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tnumber_minus_spanset(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3291,9 +3097,6 @@ void TemporalFunctions::Tnumber_minus_spanset(DataChunk &args, ExpressionState & return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tnumber_at_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3331,9 +3134,6 @@ void TemporalFunctions::Tnumber_at_tbox(DataChunk &args, ExpressionState &state, return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tnumber_minus_tbox(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3371,9 +3171,6 @@ void TemporalFunctions::Tnumber_minus_tbox(DataChunk &args, ExpressionState &sta return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_minus_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3403,9 +3200,6 @@ void TemporalFunctions::Temporal_minus_timestamptz(DataChunk &args, ExpressionSt return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_value_at_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3531,9 +3325,6 @@ void TemporalFunctions::Temporal_value_at_timestamptz(DataChunk &args, Expressio throw InvalidInputException("Unsupported result type for valueAtTimestamp"); } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_at_tstzset(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3573,9 +3364,6 @@ void TemporalFunctions::Temporal_at_tstzset(DataChunk &args, ExpressionState &st return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_minus_tstzset(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3615,9 +3403,6 @@ void TemporalFunctions::Temporal_minus_tstzset(DataChunk &args, ExpressionState return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_minus_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3658,9 +3443,6 @@ void TemporalFunctions::Temporal_minus_tstzspan(DataChunk &args, ExpressionState return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_minus_tstzspanset(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3701,9 +3483,6 @@ void TemporalFunctions::Temporal_minus_tstzspanset(DataChunk &args, ExpressionSt return stored; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_before_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3741,9 +3520,6 @@ void TemporalFunctions::Temporal_before_timestamptz(DataChunk &args, ExpressionS return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_after_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3781,9 +3557,6 @@ void TemporalFunctions::Temporal_after_timestamptz(DataChunk &args, ExpressionSt return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tnumber_valuespans(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3818,9 +3591,6 @@ void TemporalFunctions::Tnumber_valuespans(DataChunk &args, ExpressionState &sta return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tnumber_avg_value(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3844,9 +3614,6 @@ void TemporalFunctions::Tnumber_avg_value(DataChunk &args, ExpressionState &stat return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** * Modification Functions @@ -3900,9 +3667,6 @@ void TemporalFunctions::Temporal_insert(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_update(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3953,9 +3717,6 @@ void TemporalFunctions::Temporal_update(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_delete_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { @@ -3993,9 +3754,6 @@ void TemporalFunctions::Temporal_delete_timestamptz(DataChunk &args, ExpressionS return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_delete_tstzset(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4047,9 +3805,6 @@ void TemporalFunctions::Temporal_delete_tstzset(DataChunk &args, ExpressionState return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_delete_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4100,9 +3855,6 @@ void TemporalFunctions::Temporal_delete_tstzspan(DataChunk &args, ExpressionStat return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_delete_tstzspanset(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4154,9 +3906,6 @@ void TemporalFunctions::Temporal_delete_tstzspanset(DataChunk &args, ExpressionS return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } @@ -4198,9 +3947,6 @@ void TemporalFunctions::Temporal_segm_min_duration(DataChunk &args, ExpressionSt return stored; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_segm_max_duration(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4238,9 +3984,6 @@ void TemporalFunctions::Temporal_segm_max_duration(DataChunk &args, ExpressionSt return stored; } ); - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -4266,9 +4009,6 @@ void TemporalFunctions::Tnumber_integral(DataChunk &args, ExpressionState &state return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Tnumber_twavg(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4291,9 +4031,6 @@ void TemporalFunctions::Tnumber_twavg(DataChunk &args, ExpressionState &state, V return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** * Comparison operators @@ -4332,9 +4069,6 @@ void TemporalFunctions::Temporal_eq(DataChunk &args, ExpressionState &state, Vec return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_ne(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4371,9 +4105,6 @@ void TemporalFunctions::Temporal_ne(DataChunk &args, ExpressionState &state, Vec return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_le(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4410,9 +4141,6 @@ void TemporalFunctions::Temporal_le(DataChunk &args, ExpressionState &state, Vec return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_lt(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4449,9 +4177,6 @@ void TemporalFunctions::Temporal_lt(DataChunk &args, ExpressionState &state, Vec return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_ge(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4488,9 +4213,6 @@ void TemporalFunctions::Temporal_ge(DataChunk &args, ExpressionState &state, Vec return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_gt(DataChunk &args, ExpressionState &state, Vector &result) { BinaryExecutor::ExecuteWithNulls( @@ -4526,9 +4248,6 @@ void TemporalFunctions::Temporal_gt(DataChunk &args, ExpressionState &state, Vec return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_cmp(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4565,9 +4284,6 @@ void TemporalFunctions::Temporal_cmp(DataChunk &args, ExpressionState &state, Ve return ret; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -4608,9 +4324,6 @@ void TemporalFunctions::Tbool_when_true(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -4619,22 +4332,6 @@ void TemporalFunctions::Tbool_when_true(DataChunk &args, ExpressionState &state, namespace { -// Helper: Temporal* -> string_t result blob -inline string_t TemporalToBlob(Vector &result, Temporal *t) { - size_t sz = temporal_mem_size(t); - string_t out = StringVector::AddStringOrBlob(result, (const char *)t, sz); - free(t); - return out; -} - -// Helper: copy string_t blob into a malloc'd Temporal* -inline Temporal *BlobToTemporal(string_t blob) { - size_t sz = blob.GetSize(); - uint8_t *copy = (uint8_t *)malloc(sz); - memcpy(copy, blob.GetData(), sz); - return reinterpret_cast(copy); -} - template void TemporalUnary(DataChunk &args, Vector &result, Fn fn) { UnaryExecutor::Execute( @@ -4867,9 +4564,6 @@ void RunTboxesEmit(DataChunk &args, Vector &result, Producer produce, bool has_n total += count; free(boxes); } - if (row_count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } } // namespace @@ -5302,9 +4996,6 @@ void RunSimilarityPath(DataChunk &args, Vector &result, total += count; free(matches); } - if (row_count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } (void) fn_name; } @@ -5635,7 +5326,6 @@ void TemporalFunctions::Temporal_tprecision(DataChunk &args, ExpressionState &st out_data[row] = StringVector::AddStringOrBlob(result, blob); free(r); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } void TemporalFunctions::Temporal_tsample(DataChunk &args, ExpressionState &state, Vector &result) { @@ -5684,7 +5374,6 @@ void TemporalFunctions::Temporal_tsample(DataChunk &args, ExpressionState &state out_data[row] = StringVector::AddStringOrBlob(result, blob); free(r); } - if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); } /* *************************************************** @@ -5902,9 +5591,6 @@ void TemporalFunctions::Temporal_dump_common(DataChunk &args, Vector &result, Me free(extracted_values); free(temp); } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_dump(DataChunk &args, ExpressionState &state, Vector &result) { @@ -5978,9 +5664,6 @@ void TemporalFunctions::Temporal_round(DataChunk &args, ExpressionState &state, return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_derivative(DataChunk &args, ExpressionState &state, Vector &result) { @@ -6013,9 +5696,6 @@ void TemporalFunctions::Temporal_derivative(DataChunk &args, ExpressionState &st return stored_data; } ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } /* *************************************************** @@ -6072,9 +5752,6 @@ void TemporalFunctions::Temporal_as_wkb(DataChunk &args, ExpressionState &state, free(temp); return stored; }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } void TemporalFunctions::Temporal_as_hexwkb(DataChunk &args, ExpressionState &state, Vector &result) { @@ -6112,9 +5789,6 @@ void TemporalFunctions::Temporal_as_hexwkb(DataChunk &args, ExpressionState &sta free(temp); return stored; }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } } } // namespace duckdb