diff --git a/CMakeLists.txt b/CMakeLists.txt index bdc2247ce..43632d5be 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,14 +1,9 @@ -cmake_minimum_required (VERSION 3.5) +cmake_minimum_required (VERSION 3.12) -if (CMAKE_VERSION VERSION_EQUAL 3.12 OR CMAKE_VERSION VERSION_GREATER 3.12) - project (mongocrypt C) +project (mongocrypt C) - # Used for the csfle-markup util: - enable_language (CXX OPTIONAL) -else () - # GenerateExportHeader only works with C with 3.12 - https://gitlab.kitware.com/cmake/cmake/commit/de348a9638bd51af4523f36c68884b901d4aff18 - project (mongocrypt C CXX) -endif () +# Used for the csfle-markup util: +enable_language (CXX OPTIONAL) set (CMAKE_C_STANDARD 99) @@ -25,6 +20,7 @@ list (APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) include (GNUInstallDirs) include (ImportBSON) +include (IntelDFP) if (USE_SHARED_LIBBSON AND ENABLE_BUILD_FOR_PPA) message (FATAL_ERROR "PPA build requires static linking to libbson") @@ -249,6 +245,7 @@ target_link_libraries ( _mongocrypt::libbson_for_shared Threads::Threads kms_message_static + mongocrypt::intel_dfp $ PUBLIC ${CMAKE_DL_LIBS} @@ -306,6 +303,7 @@ target_link_libraries ( PRIVATE _mongocrypt::libbson_for_static kms_message_static + mongocrypt::intel_dfp $ PUBLIC ${CMAKE_THREAD_LIBS_INIT} @@ -492,10 +490,27 @@ foreach (test IN ITEMS path str) endforeach () if ("cxx_relaxed_constexpr" IN_LIST CMAKE_CXX_COMPILE_FEATURES) - add_executable(mlib.int128.test src/mlib/int128.test.cpp src/mlib/int128.test.c) - add_test (mlib.int128 mlib.int128.test) - target_link_libraries (mlib.int128.test PRIVATE mongo::mlib Threads::Threads) - target_compile_features (mlib.int128.test PRIVATE cxx_relaxed_constexpr) + file (GLOB_RECURSE test_files CONFIGURE_DEPENDS src/*.test.cpp) + foreach (file IN LISTS test_files) + # Compute a nice test name + file (RELATIVE_PATH relpath "${CMAKE_CURRENT_LIST_DIR}/src" "${file}") + file (TO_CMAKE_PATH "${relpath}" relpath) + string (REPLACE "src/" "" relpath "${relpath}") + string (REPLACE "/" "." test_name "${relpath}") + string (REGEX REPLACE "\\.test\\.cpp$" "" test_name "${test_name}") + # Generate a test executable: + set (exe_name "${test_name}.test") + add_executable ("${exe_name}" "${file}") + target_compile_features ("${exe_name}" PRIVATE cxx_relaxed_constexpr) + target_link_libraries ("${exe_name}" PRIVATE + mongocrypt + mongo::mlib + mongocrypt::intel_dfp + Threads::Threads + bson_static + ) + add_test ("${test_name}" "${exe_name}") + endforeach () endif () if ("cxx_std_20" IN_LIST CMAKE_CXX_COMPILE_FEATURES) diff --git a/bindings/node/.evergreen/find_cmake.sh b/bindings/node/.evergreen/find_cmake.sh deleted file mode 100644 index 3242523f4..000000000 --- a/bindings/node/.evergreen/find_cmake.sh +++ /dev/null @@ -1,48 +0,0 @@ -#!/usr/bin/env bash - -# Copied from the mongo-c-driver -find_cmake () -{ - # Check if on macOS with arm64. Use system cmake. See BUILD-14565. - OS_NAME=$(uname -s | tr '[:upper:]' '[:lower:]') - MARCH=$(uname -m | tr '[:upper:]' '[:lower:]') - if [ "darwin" = "$OS_NAME" -a "arm64" = "$MARCH" ]; then - CMAKE=cmake - return 0 - fi - - if [ ! -z "$CMAKE" ]; then - return 0 - elif [ -f "/Applications/cmake-3.2.2-Darwin-x86_64/CMake.app/Contents/bin/cmake" ]; then - CMAKE="/Applications/cmake-3.2.2-Darwin-x86_64/CMake.app/Contents/bin/cmake" - elif [ -f "/Applications/Cmake.app/Contents/bin/cmake" ]; then - CMAKE="/Applications/Cmake.app/Contents/bin/cmake" - elif [ -f "/opt/cmake/bin/cmake" ]; then - CMAKE="/opt/cmake/bin/cmake" - elif [ -z "$IGNORE_SYSTEM_CMAKE" ] && command -v cmake 2>/dev/null; then - CMAKE=cmake - elif uname -a | grep -iq 'x86_64 GNU/Linux'; then - curl --retry 5 https://cmake.org/files/v3.11/cmake-3.11.0-Linux-x86_64.tar.gz -sS --max-time 120 --fail --output cmake.tar.gz - mkdir cmake-3.11.0 - tar xzf cmake.tar.gz -C cmake-3.11.0 --strip-components=1 - CMAKE=$(pwd)/cmake-3.11.0/bin/cmake - fi - if [ -z "$CMAKE" -o -z "$( $CMAKE --version 2>/dev/null )" ]; then - # Some images have no cmake yet, or a broken cmake (see: BUILD-8570) - echo "-- MAKE CMAKE --" - CMAKE_INSTALL_DIR=$(readlink -f cmake-install) - curl --retry 5 https://cmake.org/files/v3.11/cmake-3.11.0.tar.gz -sS --max-time 120 --fail --output cmake.tar.gz - tar xzf cmake.tar.gz - cd cmake-3.11.0 - ./bootstrap --prefix="${CMAKE_INSTALL_DIR}" - make -j8 - make install - cd .. - CMAKE="${CMAKE_INSTALL_DIR}/bin/cmake" - echo "-- DONE MAKING CMAKE --" - fi -} - -find_cmake - -export CMAKE=$CMAKE diff --git a/bindings/node/.evergreen/setup_environment.sh b/bindings/node/.evergreen/setup_environment.sh index c037fa783..ec92c7afb 100755 --- a/bindings/node/.evergreen/setup_environment.sh +++ b/bindings/node/.evergreen/setup_environment.sh @@ -1,10 +1,5 @@ #!/usr/bin/env bash -if [ -z "$NODE_NVM_USE_VERSION" ]; then - echo "NODE_NVM_USE_VERSION environment variable must be set." - exit 1 -fi - set -o xtrace # Write all commands first to stderr set -o errexit # Exit the script with error if any of the commands fail @@ -26,16 +21,8 @@ mkdir -p "${BIN_DIR}" # Add mongodb toolchain to path export PATH="$BIN_DIR:/opt/mongodbtoolchain/v2/bin:$PATH" -# locate cmake -if [ "$OS" == "Windows_NT" ]; then - CMAKE=/cygdrive/c/cmake/bin/cmake - if [ "$WINDOWS_32BIT" != "ON" ]; then - ADDITIONAL_CMAKE_FLAGS="-Thost=x64 -A x64" - fi -else - chmod u+x ./.evergreen/find_cmake.sh - IGNORE_SYSTEM_CMAKE=1 . ./.evergreen/find_cmake.sh -fi +test -n "${NODE_NVM_USE_VERSION-}" || echo "Defaulting to using the current Node LTS Release. Set NODE_NVM_USE_VERSION to change." +: "${NODE_NVM_USE_VERSION:="lts"}" # this needs to be explicitly exported for the nvm install below export NVM_DIR="${NODE_ARTIFACTS_PATH}/nvm" diff --git a/bindings/node/.evergreen/test.sh b/bindings/node/.evergreen/test.sh index 2762d7782..92749dae2 100755 --- a/bindings/node/.evergreen/test.sh +++ b/bindings/node/.evergreen/test.sh @@ -11,7 +11,7 @@ export MONGODB_CLIENT_ENCRYPTION_OVERRIDE="$(pwd)" # install node dependencies echo "Installing package dependencies (includes a static build)" -. ./etc/build-static.sh +bash ./etc/build-static.sh # npm install # Run tests @@ -21,4 +21,4 @@ MONGODB_NODE_SKIP_LIVE_TESTS=true npm test # Run prebuild and deploy echo "Running prebuild and deploy" -. ./.evergreen/prebuild.sh +bash ./.evergreen/prebuild.sh diff --git a/bindings/node/etc/build-static.sh b/bindings/node/etc/build-static.sh index e99f48b65..c91580972 100755 --- a/bindings/node/etc/build-static.sh +++ b/bindings/node/etc/build-static.sh @@ -1,33 +1,35 @@ -#!/usr/bin/env bash -x +#!/usr/bin/env bash -DEPS_PREFIX="$(pwd)/deps" +THIS_DIR="$(dirname "${BASH_SOURCE[0]}")" +. "$THIS_DIR/../../../.evergreen/init.sh" + +NODE_DIR="$(abspath "$THIS_DIR/..")" + +DEPS_PREFIX="$NODE_DIR/deps" BUILD_DIR=$DEPS_PREFIX/tmp -LIBMONGOCRYPT_DIR="$(pwd)/../../" -TOP_DIR="$(pwd)/../../../" +: "${CMAKE_FLAGS:=}" +: "${WINDOWS_CMAKE_FLAGS:=}" +: "${NPM_OPTIONS:=}" export NPM_OPTIONS="${NPM_OPTIONS}" -if [[ -z $CMAKE ]]; then - CMAKE=`type -P cmake` -fi - # build and install libmongocrypt mkdir -p $BUILD_DIR/libmongocrypt-build pushd $BUILD_DIR/libmongocrypt-build #./deps/tmp/libmongocrypt-build CMAKE_FLAGS="-DDISABLE_NATIVE_CRYPTO=1 -DCMAKE_INSTALL_LIBDIR=lib -DENABLE_MORE_WARNINGS_AS_ERRORS=ON" -if [ "$OS" == "Windows_NT" ]; then - if [ "$WINDOWS_32BIT" != "ON" ]; then +if [ "$OS_NAME" == "windows" ]; then + if [ "${WINDOWS_32BIT-}" != "ON" ]; then WINDOWS_CMAKE_FLAGS="-Thost=x64 -A x64 -DCMAKE_C_FLAGS_RELWITHDEBINFO=\"/MT\"" else WINDOWS_CMAKE_FLAGS="-DCMAKE_C_FLAGS_RELWITHDEBINFO=\"/MT\"" fi - $CMAKE $CMAKE_FLAGS $WINDOWS_CMAKE_FLAGS -DCMAKE_PREFIX_PATH="`cygpath -w $DEPS_PREFIX`" -DCMAKE_INSTALL_PREFIX="`cygpath -w $DEPS_PREFIX`" "`cygpath -w $LIBMONGOCRYPT_DIR`" + run_cmake $CMAKE_FLAGS $WINDOWS_CMAKE_FLAGS -DCMAKE_PREFIX_PATH="$(native_path "$DEPS_PREFIX")" -DCMAKE_INSTALL_PREFIX="$(native_path "$DEPS_PREFIX")" "$(native_path "$LIBMONGOCRYPT_DIR")" else - $CMAKE $CMAKE_FLAGS -DCMAKE_PREFIX_PATH=$DEPS_PREFIX -DCMAKE_INSTALL_PREFIX=$DEPS_PREFIX -DCMAKE_OSX_DEPLOYMENT_TARGET="10.12" $LIBMONGOCRYPT_DIR + run_cmake $CMAKE_FLAGS -DCMAKE_PREFIX_PATH=$DEPS_PREFIX -DCMAKE_INSTALL_PREFIX=$DEPS_PREFIX -DCMAKE_OSX_DEPLOYMENT_TARGET="10.12" $LIBMONGOCRYPT_DIR fi -$CMAKE --build . --target install --config RelWithDebInfo +run_cmake --build . --target install --config RelWithDebInfo popd #./ diff --git a/cmake/IntelDFP.cmake b/cmake/IntelDFP.cmake new file mode 100644 index 000000000..b2ce753d9 --- /dev/null +++ b/cmake/IntelDFP.cmake @@ -0,0 +1,396 @@ + +include (FetchContent) +find_program (GIT_EXECUTABLE git) + +set (_default_url "https://netlib.org/misc/intel/IntelRDFPMathLib20U2.tar.gz") + +set (INTEL_DFP_LIBRARY_URL "${_default_url}" + CACHE STRING "The URL of an Intel DFP library to use") +set (INTEL_DFP_LIBRARY_URL_HASH + "SHA256=93c0c78e0989df88f8540bf38d6743734804cef1e40706fd8fe5c6a03f79e173" + CACHE STRING "The hash of the archive that lives at INTEL_DFP_LIBRARY_URL (Spelled: =)") +option (INTEL_DFP_LIBRARY_PATCH_ENABLED + "Whether to apply the s390x compatibility patch to the Intel DFP library" ON) + +set (_hash_arg) +if (NOT INTEL_DFP_LIBRARY_URL_SHA256 STREQUAL "no-verify") + set (_hash_arg URL_HASH "${INTEL_DFP_LIBRARY_URL_HASH}") +endif () + +# Make the PATCH_COMMAND a no-op if it was disabled +set (_patch_disabler) +if (NOT INTEL_DFP_LIBRARY_PATCH_ENABLED) + set (_patch_disabler "${CMAKE_COMMAND}" -E true) +endif () + +# NOTE: The applying of the patch expects the correct input directly from the +# expanded archive. If the patch needs to be reapplied, you may see errors +# about trying to update the intel_dfp component. If you are seeing such +# errors, delete the `_deps/` subdirectory in the build tree and +# re-run CMake the project. +FetchContent_Declare ( + intel_dfp + URL "${_default_url}" + ${_hash_arg} + PATCH_COMMAND + ${_patch_disabler} + "${GIT_EXECUTABLE}" --work-tree= apply + -p 4 # Strip four path components + "${PROJECT_SOURCE_DIR}/etc/mongo-inteldfp-s390x.patch" + --verbose + ) + +FetchContent_GetProperties (intel_dfp) +if (NOT intel_dfp_POPULATED) + message (STATUS "Obtaining Intel Decimal FP library: ${INTEL_DFP_LIBRARY_URL}") + FetchContent_Populate (intel_dfp) +endif () + +# This list of sources matches the ones used within MongoDB server. The +# "" prefix is replaced below. +# Refer: https://github.com/mongodb/mongo/blob/e9be40f47a77af1931773ad671d4927c0fe6969a/src/third_party/IntelRDFPMathLib20U1/SConscript +set (_dfp_sources + "/float128/dpml_exception.c" + "/float128/dpml_four_over_pi.c" + "/float128/dpml_ux_bessel.c" + "/float128/dpml_ux_bid.c" + "/float128/dpml_ux_cbrt.c" + "/float128/dpml_ux_erf.c" + "/float128/dpml_ux_exp.c" + "/float128/dpml_ux_int.c" + "/float128/dpml_ux_inv_hyper.c" + "/float128/dpml_ux_inv_trig.c" + "/float128/dpml_ux_lgamma.c" + "/float128/dpml_ux_log.c" + "/float128/dpml_ux_mod.c" + "/float128/dpml_ux_ops.c" + "/float128/dpml_ux_ops_64.c" + "/float128/dpml_ux_pow.c" + "/float128/dpml_ux_powi.c" + "/float128/dpml_ux_sqrt.c" + "/float128/dpml_ux_trig.c" + "/float128/sqrt_tab_t.c" + "/src/bid128.c" + "/src/bid128_2_str_tables.c" + "/src/bid128_acos.c" + "/src/bid128_acosh.c" + "/src/bid128_add.c" + "/src/bid128_asin.c" + "/src/bid128_asinh.c" + "/src/bid128_atan.c" + "/src/bid128_atan2.c" + "/src/bid128_atanh.c" + "/src/bid128_cbrt.c" + "/src/bid128_compare.c" + "/src/bid128_cos.c" + "/src/bid128_cosh.c" + "/src/bid128_div.c" + "/src/bid128_erf.c" + "/src/bid128_erfc.c" + "/src/bid128_exp.c" + "/src/bid128_exp10.c" + "/src/bid128_exp2.c" + "/src/bid128_expm1.c" + "/src/bid128_fdimd.c" + "/src/bid128_fma.c" + "/src/bid128_fmod.c" + "/src/bid128_frexp.c" + "/src/bid128_hypot.c" + "/src/bid128_ldexp.c" + "/src/bid128_lgamma.c" + "/src/bid128_llrintd.c" + "/src/bid128_log.c" + "/src/bid128_log10.c" + "/src/bid128_log1p.c" + "/src/bid128_log2.c" + "/src/bid128_logb.c" + "/src/bid128_logbd.c" + "/src/bid128_lrintd.c" + "/src/bid128_lround.c" + "/src/bid128_minmax.c" + "/src/bid128_modf.c" + "/src/bid128_mul.c" + "/src/bid128_nearbyintd.c" + "/src/bid128_next.c" + "/src/bid128_nexttowardd.c" + "/src/bid128_noncomp.c" + "/src/bid128_pow.c" + "/src/bid128_quantexpd.c" + "/src/bid128_quantize.c" + "/src/bid128_rem.c" + "/src/bid128_round_integral.c" + "/src/bid128_scalb.c" + "/src/bid128_scalbl.c" + "/src/bid128_sin.c" + "/src/bid128_sinh.c" + "/src/bid128_sqrt.c" + "/src/bid128_string.c" + "/src/bid128_tan.c" + "/src/bid128_tanh.c" + "/src/bid128_tgamma.c" + "/src/bid128_to_int16.c" + "/src/bid128_to_int32.c" + "/src/bid128_to_int64.c" + "/src/bid128_to_int8.c" + "/src/bid128_to_uint16.c" + "/src/bid128_to_uint32.c" + "/src/bid128_to_uint64.c" + "/src/bid128_to_uint8.c" + "/src/bid32_acos.c" + "/src/bid32_acosh.c" + "/src/bid32_add.c" + "/src/bid32_asin.c" + "/src/bid32_asinh.c" + "/src/bid32_atan.c" + "/src/bid32_atan2.c" + "/src/bid32_atanh.c" + "/src/bid32_cbrt.c" + "/src/bid32_compare.c" + "/src/bid32_cos.c" + "/src/bid32_cosh.c" + "/src/bid32_div.c" + "/src/bid32_erf.c" + "/src/bid32_erfc.c" + "/src/bid32_exp.c" + "/src/bid32_exp10.c" + "/src/bid32_exp2.c" + "/src/bid32_expm1.c" + "/src/bid32_fdimd.c" + "/src/bid32_fma.c" + "/src/bid32_fmod.c" + "/src/bid32_frexp.c" + "/src/bid32_hypot.c" + "/src/bid32_ldexp.c" + "/src/bid32_lgamma.c" + "/src/bid32_llrintd.c" + "/src/bid32_log.c" + "/src/bid32_log10.c" + "/src/bid32_log1p.c" + "/src/bid32_log2.c" + "/src/bid32_logb.c" + "/src/bid32_logbd.c" + "/src/bid32_lrintd.c" + "/src/bid32_lround.c" + "/src/bid32_minmax.c" + "/src/bid32_modf.c" + "/src/bid32_mul.c" + "/src/bid32_nearbyintd.c" + "/src/bid32_next.c" + "/src/bid32_nexttowardd.c" + "/src/bid32_noncomp.c" + "/src/bid32_pow.c" + "/src/bid32_quantexpd.c" + "/src/bid32_quantize.c" + "/src/bid32_rem.c" + "/src/bid32_round_integral.c" + "/src/bid32_scalb.c" + "/src/bid32_scalbl.c" + "/src/bid32_sin.c" + "/src/bid32_sinh.c" + "/src/bid32_sqrt.c" + "/src/bid32_string.c" + "/src/bid32_sub.c" + "/src/bid32_tan.c" + "/src/bid32_tanh.c" + "/src/bid32_tgamma.c" + "/src/bid32_to_bid128.c" + "/src/bid32_to_bid64.c" + "/src/bid32_to_int16.c" + "/src/bid32_to_int32.c" + "/src/bid32_to_int64.c" + "/src/bid32_to_int8.c" + "/src/bid32_to_uint16.c" + "/src/bid32_to_uint32.c" + "/src/bid32_to_uint64.c" + "/src/bid32_to_uint8.c" + "/src/bid64_acos.c" + "/src/bid64_acosh.c" + "/src/bid64_add.c" + "/src/bid64_asin.c" + "/src/bid64_asinh.c" + "/src/bid64_atan.c" + "/src/bid64_atan2.c" + "/src/bid64_atanh.c" + "/src/bid64_cbrt.c" + "/src/bid64_compare.c" + "/src/bid64_cos.c" + "/src/bid64_cosh.c" + "/src/bid64_div.c" + "/src/bid64_erf.c" + "/src/bid64_erfc.c" + "/src/bid64_exp.c" + "/src/bid64_exp10.c" + "/src/bid64_exp2.c" + "/src/bid64_expm1.c" + "/src/bid64_fdimd.c" + "/src/bid64_fma.c" + "/src/bid64_fmod.c" + "/src/bid64_frexp.c" + "/src/bid64_hypot.c" + "/src/bid64_ldexp.c" + "/src/bid64_lgamma.c" + "/src/bid64_llrintd.c" + "/src/bid64_log.c" + "/src/bid64_log10.c" + "/src/bid64_log1p.c" + "/src/bid64_log2.c" + "/src/bid64_logb.c" + "/src/bid64_logbd.c" + "/src/bid64_lrintd.c" + "/src/bid64_lround.c" + "/src/bid64_minmax.c" + "/src/bid64_modf.c" + "/src/bid64_mul.c" + "/src/bid64_nearbyintd.c" + "/src/bid64_next.c" + "/src/bid64_nexttowardd.c" + "/src/bid64_noncomp.c" + "/src/bid64_pow.c" + "/src/bid64_quantexpd.c" + "/src/bid64_quantize.c" + "/src/bid64_rem.c" + "/src/bid64_round_integral.c" + "/src/bid64_scalb.c" + "/src/bid64_scalbl.c" + "/src/bid64_sin.c" + "/src/bid64_sinh.c" + "/src/bid64_sqrt.c" + "/src/bid64_string.c" + "/src/bid64_tan.c" + "/src/bid64_tanh.c" + "/src/bid64_tgamma.c" + "/src/bid64_to_bid128.c" + "/src/bid64_to_int16.c" + "/src/bid64_to_int32.c" + "/src/bid64_to_int64.c" + "/src/bid64_to_int8.c" + "/src/bid64_to_uint16.c" + "/src/bid64_to_uint32.c" + "/src/bid64_to_uint64.c" + "/src/bid64_to_uint8.c" + "/src/bid_binarydecimal.c" + "/src/bid_convert_data.c" + "/src/bid_decimal_data.c" + "/src/bid_decimal_globals.c" + "/src/bid_dpd.c" + "/src/bid_feclearexcept.c" + "/src/bid_fegetexceptflag.c" + "/src/bid_feraiseexcept.c" + "/src/bid_fesetexceptflag.c" + "/src/bid_fetestexcept.c" + "/src/bid_flag_operations.c" + "/src/bid_from_int.c" + "/src/bid_round.c" + "/src/strtod128.c" + "/src/strtod32.c" + "/src/strtod64.c" + "/src/wcstod128.c" + "/src/wcstod32.c" + "/src/wcstod64.c" + ) +# Put in the actual library path: +string (REPLACE "" "${intel_dfp_SOURCE_DIR}/LIBRARY" _dfp_sources "${_dfp_sources}") + +#[[ + Intel DFP gives us a very blunt yet powerful hammer to avoid symbol + collision, since other library may also want a conflicting + DFP version: Just rename everything! + + All function names are #defined with a `bid` or `binary` prefix, and are + aliased to their "actual" names with a `__bid` or `__binary` prefix, + respectively. + + So we can ship our own decimal library without worry, we'll rename those + hidden symbols. +]] +file (READ "${intel_dfp_SOURCE_DIR}/LIBRARY/src/bid_conf.h" dfp_conf_content) +string (REGEX REPLACE + #[[ + Match every "#define X Y" where X begins with `"bid" or "binary", and Y + begins with "__bid" or "__binary". X and Y must be separated by one or + more spaces. + ]] + "#define ((bid|binary)[^ ]+ +)__(bid|binary)([^ +])" + # Replace Y with "__mongocrypt_bid" or "__mongocrypt_binary" as the new prefix. + "#define \\1 __mongocrypt_\\3\\4" + new_content "${dfp_conf_content}" + ) +if (NOT new_content STREQUAL dfp_conf_content) + # Only rewrite the file if we changed anything, otherwise we update build + # input timestamps and will trigger a rebuild of DFP. + file (WRITE "${intel_dfp_SOURCE_DIR}/LIBRARY/src/bid_conf.h" "${new_content}") +endif () + +# Define the object library +add_library (intel_dfp_obj OBJECT ${_dfp_sources}) +# Build with -fPIC, since these objects may go into a static OR dynamic library. +set_property (TARGET intel_dfp_obj PROPERTY POSITION_INDEPENDENT_CODE TRUE) + +# DFP needs information about the build target platform. Compute that: +set (proc_lower $) +set (ia32_list i386 emscripted x86 arm) +set (efi2_list aarch64 arm64 x86_64 ppc64le riscv64) + +set (is_linux $) +set (is_windows $) +set (is_unix $) + +# These compiler definitions may seem a bit strange, but the whole DFP library's +# config process is strange. These options match those used in MongoDB server. +target_compile_definitions (intel_dfp_obj PRIVATE + DECIMAL_CALL_BY_REFERENCE=0 + DECIMAL_GLOBAL_ROUNDING=0 + DECIMAL_GLOBAL_EXCEPTION_FLAGS=0 + UNCHANGED_BINARY_STATUS_FLAGS=0 + USE_COMPILER_F128_TYPE=0 + USE_COMPILER_F80_TYPE=0 + USE_NATIVE_QUAD_TYPE=0 + $<${is_unix}:LINUX=1> + $<$:mach=1> + $<$:freebsd=1> + $<$:linux=1> + $<${is_windows}: + WINDOWS=1 + WNT=1 + winnt=1 + > + $<$: + IA32=1 + ia32=1 + > + $<$: + EFI2=1 + efi2=1 + > + $<$: + s390x=1 + BID_BIG_ENDIAN=1 + > + ) + +# Suppress warnings in the Intel library, as it generates a lot that aren't of interest +target_compile_options (intel_dfp_obj PRIVATE -w) + +# Define an interface library that attaches the built TUs to the consumer +add_library (_mongocrypt_intel_dfp INTERFACE) +add_library (mongocrypt::intel_dfp ALIAS _mongocrypt_intel_dfp) + +target_sources (_mongocrypt_intel_dfp + #[[ + For targets *within this build* that link with mongocrypt::intel_dfp, + inject the generated TUs (object files) from the intel_dfp_obj library. + + This will be stripped out of the interface library when it is installed, + since we don't want to ship the DFP object separately. Instead, users + will link to libmongocrypt, which will contain the necessary TUs for + the library (because they link to this interface library). + ]] + INTERFACE $> + ) +# We do want to propagate an interface requirement: Some platforms need a +# separate link library to support special math functions. +target_link_libraries(_mongocrypt_intel_dfp INTERFACE $<$:m>) + +# Give the installed target a name to indicate its hidden-ness +set_property (TARGET _mongocrypt_intel_dfp PROPERTY EXPORT_NAME private::intel_dfp_interface) +install (TARGETS _mongocrypt_intel_dfp EXPORT mongocrypt_targets) diff --git a/etc/mongo-inteldfp-s390x.patch b/etc/mongo-inteldfp-s390x.patch new file mode 100644 index 000000000..480ed3bcd --- /dev/null +++ b/etc/mongo-inteldfp-s390x.patch @@ -0,0 +1,125 @@ +diff --git a/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/architecture.h b/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/architecture.h +index 3eb9fbb17a80..355d70e813bb 100755 +--- a/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/architecture.h ++++ b/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/architecture.h +@@ -570,8 +570,65 @@ + # endif + + ++#elif (defined(__s390x__)) + ++# undef vax ++# undef mips ++# undef hp_pa ++# undef cray ++# undef alpha ++# undef ix86 ++# undef merced ++# undef amd64 ++# undef sparc ++ ++# define s390 10 ++# define ARCHITECTURE s390 ++ ++# define LOCAL_DATA 1 ++# undef STATIC_ROUNDING_MODES ++# define DYNAMIC_ROUNDING_MODES 1 ++# define DENORMS_EMULATED 1 ++# define SEPARATE_FLOAT_REGS 1 ++# undef MULTIPLE_ISSUE ++# undef UNSIGNED_TO_FLOAT ++# define UNSIGNED_MULTIPLY 1 ++# define ENDIANESS big_endian ++# define SCALE_METHOD by_int ++# define CVT_TO_HI_LO_METHOD by_flt ++ ++# define BITS_PER_CHAR 8 ++# define BITS_PER_SHORT 16 ++# define BITS_PER_INT 32 ++# define BITS_PER_LONG 64 ++ ++# define BITS_PER_ADDRESS 64 ++ ++# define BITS_PER_FLOAT 32 ++# define BITS_PER_DOUBLE 64 ++# define BITS_PER_LONG_DOUBLE 128 ++# define LONG_DOUBLE_128_TYPE _Quad ++ ++# define __INT_64 long long ++ ++# define INT_8 signed char ++# define INT_16 signed short ++# define INT_32 signed int ++# define INT_64 signed __INT_64 ++# undef INT_128 ++# define U_INT_8 unsigned char ++# define U_INT_16 unsigned short ++# define U_INT_32 unsigned int ++# define U_INT_64 unsigned __INT_64 ++# undef U_INT_128 + ++ /* Setup for 64 bits */ ++# define WORD INT_64 ++# define U_WORD U_INT_64 ++# define BITS_PER_WORD 64 ++# define HALF_WORD INT_32 ++# define U_HALF_WORD U_INT_32 ++# define BITS_PER_HALF_WORD 32 + + + #elif (defined(_M_AMD64)) +diff --git a/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/dpml_private.h b/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/dpml_private.h +index 2d429afafc17..d57406c9014c 100755 +--- a/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/dpml_private.h ++++ b/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/dpml_private.h +@@ -242,6 +242,10 @@ versions until we need them. ] */ + + # include "ix86_macros.h" + ++#elif (ARCHITECTURE == s390 ) ++ ++# include "ix86_macros.h" ++ + #else + + # error Unknown ARCHITECTURE. +diff --git a/src/third_party/IntelRDFPMathLib20U1/TESTS/readtest.c b/src/third_party/IntelRDFPMathLib20U1/TESTS/readtest.c +index afb77da454c2..24e91685de52 100755 +--- a/src/third_party/IntelRDFPMathLib20U1/TESTS/readtest.c ++++ b/src/third_party/IntelRDFPMathLib20U1/TESTS/readtest.c +@@ -449,7 +449,7 @@ BID_UINT32 a32, b32, c32, q32, r32; + BID_UINT64 a64, b64, c64, q64, r64; + BID_UINT128 a, b, c, q, r; + +-char AI8; ++signed char AI8; + unsigned char AUI8; + short AI16, BI16; + unsigned short AUI16, BUI16; +@@ -466,7 +466,7 @@ unsigned short u1_16, u2_16; + short i1_16, i2_16; + + unsigned char u1_8, u2_8; +-char i1_8, i2_8; ++signed char i1_8, i2_8; + + unsigned int expected_status; + +diff --git a/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/dpml_ux_ops.c b/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/dpml_ux_ops.c +--- a/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/dpml_ux_ops.c ++++ b/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/dpml_ux_ops.c +@@ -666,3 +666,3 @@ + } +- return fp_class | ((WORD) 1 << (BITS_PER_WORD - 1)); ++ return fp_class | ((U_WORD) 1 << (BITS_PER_WORD - 1)); + } + +diff --git a/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/dpml_ux.h b/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/dpml_ux.h +--- a/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/dpml_ux.h ++++ b/src/third_party/IntelRDFPMathLib20U1/LIBRARY/float128/dpml_ux.h +@@ -129,3 +129,3 @@ + #define UX_UNDERFLOW_EXPONENT (- UX_OVERFLOW_EXPONENT) +-#define UX_ZERO_EXPONENT (- (UX_EXPONENT_TYPE) 1 << (F_EXP_WIDTH + 2)) ++#define UX_ZERO_EXPONENT (- ((UX_EXPONENT_TYPE) 1 << (F_EXP_WIDTH + 2))) + #define UX_INFINITY_EXPONENT (-(UX_ZERO_EXPONENT + 1)) + diff --git a/src/mc-dec128.h b/src/mc-dec128.h new file mode 100644 index 000000000..a5ffcf0b3 --- /dev/null +++ b/src/mc-dec128.h @@ -0,0 +1,686 @@ +#ifndef MC_DEC128_H_INCLUDED +#define MC_DEC128_H_INCLUDED + +#include + +#include +#include +#include + +#include +#include +#include +#include + +MLIB_C_LINKAGE_BEGIN + +/// Rounding controls for Decimal128 operations +typedef enum mc_dec128_rounding_mode { + MC_DEC128_ROUND_NEAREST_EVEN = 0, + MC_DEC128_ROUND_DOWNWARD = 1, + MC_DEC128_ROUND_UPWARD = 2, + MC_DEC128_ROUND_TOWARD_ZERO = 3, + MC_DEC128_ROUND_NEAREST_AWAY = 4, + MC_DEC128_ROUND_DEFAULT = MC_DEC128_ROUND_NEAREST_EVEN, +} mc_dec128_rounding_mode; + +typedef struct mc_dec128_flagset { + int bits; +} mc_dec128_flagset; + +// This alignment conditional is the same conditions used in Intel's DFP +// library, ensuring we match the ABI of the library without pulling the header +#if defined _MSC_VER +#if defined _M_IX86 && !defined __INTEL_COMPILER +#define _mcDec128Align(n) +#else +#define _mcDec128Align(n) __declspec(align (n)) +#endif +#else +#if !defined HPUX_OS +#define _mcDec128Align(n) __attribute__ ((aligned (n))) +#else +#define _mcDec128Align(n) +#endif +#endif + +typedef union _mcDec128Align (16) +{ + uint64_t _words[2]; +#if !defined(__INTELLISENSE__) && defined(__GNUC__) && defined(__amd64) && \ + !defined(__APPLE__) && !defined(__clang__) + // If supported by the compiler, emit a field that can be used to visualize + // the value in a debugger. + float value_ __attribute__ ((mode (TD))); +#endif +} +mc_dec128; + +#undef _mcDec128Align + +/// Expands to a dec128 constant value. +#ifdef __cplusplus +#define MC_DEC128_C(N) \ + mc_dec128 _mcDec128Const (((N) < 0 ? -(N) : (N)), ((N) < 0 ? 1 : 0)) +#else +#define MC_DEC128_C(N) \ + _mcDec128Const (((N) < 0 ? -(N) : (N)), ((N) < 0 ? 1 : 0)) +#endif + +#define MC_DEC128(N) MLIB_INIT (mc_dec128) MC_DEC128_C (N) + +#define _mcDec128Combination(Bits) ((uint64_t) (Bits) << (47)) +#define _mcDec128ZeroExpCombo _mcDec128Combination (1 << 7 | 1 << 13 | 1 << 14) +#define _mcDec128Const(N, Negate) \ + _mcDec128ConstFromParts ( \ + N, (_mcDec128ZeroExpCombo | ((uint64_t) (Negate) << 63))) +#define _mcDec128ConstFromParts(CoeffLow, HighWord) \ + { \ + { \ + MLIB_IS_LITTLE_ENDIAN ? (uint64_t) (CoeffLow) \ + : (uint64_t) (HighWord), \ + MLIB_IS_LITTLE_ENDIAN ? (uint64_t) (HighWord) \ + : (uint64_t) (CoeffLow), \ + }, \ + } + +static const mc_dec128 MC_DEC128_ZERO = MC_DEC128_C (0); +static const mc_dec128 MC_DEC128_ONE = MC_DEC128_C (1); +static const mc_dec128 MC_DEC128_MINUSONE = MC_DEC128_C (-1); + +/// The greatest-magnitude finite negative value representable in a Decimal128 +#define MC_DEC128_LARGEST_NEGATIVE \ + mc_dec128_from_string ("-9999999999999999999999999999999999E6111") +/// The least-magnitude non-zero negative value representable in a Decimal128 +#define MC_DEC128_SMALLEST_NEGATIVE mc_dec128_from_string ("-1E-6176") +/// The greatest-magnitude finite positive value representable in a Decimal128 +#define MC_DEC128_LARGEST_POSITIVE \ + mc_dec128_from_string ("9999999999999999999999999999999999E6111") +/// The least-magnitude non-zero positive value representable in a Decimal128 +#define MC_DEC128_SMALLEST_POSITIVE mc_dec128_from_string ("1E-6176") +/// The normalized zero of Decimal128 +#define MC_DEC128_NORMALIZED_ZERO MC_DEC128_C (0) +/// A zero of Decimal128 with the least exponent +#define MC_DEC128_NEGATIVE_EXPONENT_ZERO mc_dec128_from_string ("0E-6176") +#define _mcDec128InfCombo \ + _mcDec128Combination (1 << 15 | 1 << 14 | 1 << 13 | 1 << 12) +#define _mcDec128QuietNaNCombo \ + _mcDec128Combination (1 << 15 | 1 << 14 | 1 << 13 | 1 << 12 | 1 << 11) + +/// Positive infinity of Decimal128 +#define MC_DEC128_POSITIVE_INFINITY \ + _mcDec128ConstFromParts (0, _mcDec128InfCombo) +/// Negative infinity of Decimal128 +#define MC_DEC128_NEGATIVE_INFINITY \ + _mcDec128ConstFromParts (0, _mcDec128InfCombo | 1ull << 63) +/// Positve quiet NaN of Decimal128 +#define MC_DEC128_POSITIVE_NAN \ + _mcDec128ConstFromParts (0, _mcDec128QuietNaNCombo) +/// Negative quiet NaN of Decimal128 +#define MC_DEC128_NEGATIVE_NAN \ + _mcDec128ConstFromParts (0, _mcDec128QuietNaNCombo | 1ull << 63) + + +/** + * @brief Convert a double-precision binary floating point value into the + * nearest Decimal128 value + * + * @param d The number to conver + * @param rnd The rounding mode in case the value is not exactly representable + * @param flags Out param for exception/error flags (Optional) + */ +static inline mc_dec128 +mc_dec128_from_double_ex (double d, + mc_dec128_rounding_mode rnd, + mc_dec128_flagset *flags) +{ + extern mc_dec128 __mongocrypt_binary64_to_bid128 ( + double d, mc_dec128_rounding_mode, mc_dec128_flagset *); + mc_dec128_flagset zero_flags = {0}; + return __mongocrypt_binary64_to_bid128 (d, rnd, flags ? flags : &zero_flags); +} + +/** + * @brief Convert a double-precision binary floating point value into the + * nearest Decimal128 value + */ +static inline mc_dec128 +mc_dec128_from_double (double d) +{ + return mc_dec128_from_double_ex (d, MC_DEC128_ROUND_DEFAULT, NULL); +} + +/** + * @brief Convert a string representation of a number into the nearest + * Decimal128 value + * + * @param s The string to parse. MUST be null-terminated + * @param rnd The rounding mode to use if the result is not representable + * @param flags Out param for exception/error flags (Optional) + */ +static inline mc_dec128 +mc_dec128_from_string_ex (const char *s, + mc_dec128_rounding_mode rnd, + mc_dec128_flagset *flags) +{ + extern mc_dec128 __mongocrypt_bid128_from_string ( + const char *, mc_dec128_rounding_mode, mc_dec128_flagset *); + mc_dec128_flagset zero_flags = {0}; + return __mongocrypt_bid128_from_string (s, rnd, flags ? flags : &zero_flags); +} + +/** + * @brief Convert a string representation of a number into the nearest + * Decimal128 value + */ +static inline mc_dec128 +mc_dec128_from_string (const char *s) +{ + return mc_dec128_from_string_ex (s, MC_DEC128_ROUND_DEFAULT, NULL); +} + +/** + * @brief A type capable of holding a string rendering of a Decimal128 in + * engineering notation. + */ +typedef struct mc_dec128_string { + /// The character array of the rendered value. Null-terminated + char str[48]; +} mc_dec128_string; + +/** + * @brief Render a Decimal128 value as a string (in engineering notation) + * + * @param d The number to represent + * @param flags Output parameter for exception/error flags (optional) + */ +static inline mc_dec128_string +mc_dec128_to_string_ex (mc_dec128 d, mc_dec128_flagset *flags) +{ + extern void __mongocrypt_bid128_to_string ( + char *, mc_dec128 d, mc_dec128_flagset *); + mc_dec128_flagset zero_flags = {0}; + mc_dec128_string out = {{0}}; + __mongocrypt_bid128_to_string (out.str, d, flags ? flags : &zero_flags); + return out; +} + +/** + * @brief Render a Decimal128 value as a string (in engineering notation) + */ +static inline mc_dec128_string +mc_dec128_to_string (mc_dec128 d) +{ + return mc_dec128_to_string_ex (d, NULL); +} + +/// Compare two dec128 numbers +#define DECL_IDF_COMPARE_1(Oper) \ + static inline bool mc_dec128_##Oper##_ex ( \ + mc_dec128 left, mc_dec128 right, mc_dec128_flagset *flags) \ + { \ + extern int __mongocrypt_bid128_quiet_##Oper ( \ + mc_dec128 left, mc_dec128 right, mc_dec128_flagset *); \ + mc_dec128_flagset zero_flags = {0}; \ + return 0 != __mongocrypt_bid128_quiet_##Oper ( \ + left, right, flags ? flags : &zero_flags); \ + } \ + \ + static inline bool mc_dec128_##Oper (mc_dec128 left, mc_dec128 right) \ + { \ + return mc_dec128_##Oper##_ex (left, right, NULL); \ + } + +#define DECL_IDF_COMPARE(Op) \ + DECL_IDF_COMPARE_1 (Op) \ + DECL_IDF_COMPARE_1 (not_##Op) + +DECL_IDF_COMPARE (equal) +DECL_IDF_COMPARE (greater) +DECL_IDF_COMPARE (greater_equal) +DECL_IDF_COMPARE (less) +DECL_IDF_COMPARE (less_equal) + +#undef DECL_IDF_COMPARE +#undef DECL_IDF_COMPARE_1 + +/// Test properties of Decimal128 numbers +#define DECL_PREDICATE(Name, BIDName) \ + static inline bool mc_dec128_##Name (mc_dec128 d) \ + { \ + extern int __mongocrypt_bid128_##BIDName (mc_dec128 d); \ + return 0 != __mongocrypt_bid128_##BIDName (d); \ + } + +DECL_PREDICATE (is_zero, isZero) +DECL_PREDICATE (is_negative, isSigned) +DECL_PREDICATE (is_inf, isInf) +DECL_PREDICATE (is_finite, isFinite) +DECL_PREDICATE (is_nan, isNaN) + +#undef DECL_PREDICATE + +/// Binary arithmetic operations on two Decimal128 numbers +#define DECL_IDF_BINOP_WRAPPER(Oper) \ + static inline mc_dec128 mc_dec128_##Oper##_ex ( \ + mc_dec128 left, \ + mc_dec128 right, \ + mc_dec128_rounding_mode mode, \ + mc_dec128_flagset *flags) \ + { \ + extern mc_dec128 __mongocrypt_bid128_##Oper ( \ + mc_dec128 left, \ + mc_dec128 right, \ + mc_dec128_rounding_mode rounding, \ + mc_dec128_flagset *flags); \ + mc_dec128_flagset zero_flags = {0}; \ + return __mongocrypt_bid128_##Oper ( \ + left, right, mode, flags ? flags : &zero_flags); \ + } \ + \ + static inline mc_dec128 mc_dec128_##Oper (mc_dec128 left, mc_dec128 right) \ + { \ + return mc_dec128_##Oper##_ex ( \ + left, right, MC_DEC128_ROUND_DEFAULT, NULL); \ + } + +DECL_IDF_BINOP_WRAPPER (add) +DECL_IDF_BINOP_WRAPPER (mul) +DECL_IDF_BINOP_WRAPPER (div) +DECL_IDF_BINOP_WRAPPER (sub) +DECL_IDF_BINOP_WRAPPER (pow) + +#undef DECL_IDF_BINOP_WRAPPER + +/// Unary arithmetic operations on two Decimal128 numbers +#define DECL_IDF_UNOP_WRAPPER(Oper) \ + static inline mc_dec128 mc_dec128_##Oper##_ex (mc_dec128 operand, \ + mc_dec128_flagset *flags) \ + { \ + extern mc_dec128 __mongocrypt_bid128_##Oper ( \ + mc_dec128 v, mc_dec128_rounding_mode, mc_dec128_flagset *); \ + mc_dec128_flagset zero_flags = {0}; \ + return __mongocrypt_bid128_##Oper ( \ + operand, MC_DEC128_ROUND_DEFAULT, flags ? flags : &zero_flags); \ + } \ + \ + static inline mc_dec128 mc_dec128_##Oper (mc_dec128 operand) \ + { \ + return mc_dec128_##Oper##_ex (operand, NULL); \ + } + +DECL_IDF_UNOP_WRAPPER (round_integral_zero) +DECL_IDF_UNOP_WRAPPER (round_integral_positive) +DECL_IDF_UNOP_WRAPPER (round_integral_negative) +DECL_IDF_UNOP_WRAPPER (round_integral_exact) +DECL_IDF_UNOP_WRAPPER (log2) +DECL_IDF_UNOP_WRAPPER (log10) +DECL_IDF_UNOP_WRAPPER (negate) +DECL_IDF_UNOP_WRAPPER (abs) +#undef DECL_IDF_UNOP_WRAPPER + +/** + * @brief Scale the given Decimal128 by a power of ten + * + * @param fac The value being scaled + * @param exp The exponent: 10^exp is the scale factor + * @param rounding Rounding behavior + * @param flags Control/result flags + * @return mc_dec128 The product + */ +static inline mc_dec128 +mc_dec128_scale_ex (mc_dec128 fac, + long int exp, + mc_dec128_rounding_mode rounding, + mc_dec128_flagset *flags) +{ + extern mc_dec128 __mongocrypt_bid128_scalbln ( + mc_dec128 fac, long int, mc_dec128_rounding_mode, mc_dec128_flagset *); + mc_dec128_flagset zero_flags = {0}; + return __mongocrypt_bid128_scalbln ( + fac, exp, rounding, flags ? flags : &zero_flags); +} + +/** + * @brief Scale the given Decimal128 by a power of ten + * + * @param fac The value being scaled + * @param exp The exponent: 10^exp is the scale factor + * @return mc_dec128 The product + */ +static inline mc_dec128 +mc_dec128_scale (mc_dec128 fac, long int exp) +{ + return mc_dec128_scale_ex (fac, exp, MC_DEC128_ROUND_DEFAULT, NULL); +} + +/// The result of a dec_128 modf operation +typedef struct mc_dec128_modf_result { + /// The whole part of the result + mc_dec128 whole; + /// The fractional part of the result + mc_dec128 frac; +} mc_dec128_modf_result; + +/** + * @brief Split a Decimal128 into its whole and fractional parts. + * + * The "whole" value is the integral value of the Decimal128 rounded towards + * zero. The "frac" part is the remainder after removing the whole. + * + * @param d The value to inspect + * @param flags Results status flags + */ +static inline mc_dec128_modf_result +mc_dec128_modf_ex (mc_dec128 d, mc_dec128_flagset *flags) +{ + extern mc_dec128 __mongocrypt_bid128_modf ( + mc_dec128 d, mc_dec128 * iptr, mc_dec128_flagset *); + mc_dec128_flagset zero_flags = {0}; + mc_dec128_modf_result res; + res.frac = + __mongocrypt_bid128_modf (d, &res.whole, flags ? flags : &zero_flags); + return res; +} + +/** + * @brief Split a Decimal128 into its whole and fractional parts. + * + * The "whole" value is the integral value of the Decimal128 rounded towards + * zero. The "frac" part is the remainder after removing the whole. + * + * @param d The value to inspect + */ +static inline mc_dec128_modf_result +mc_dec128_modf (mc_dec128 d) +{ + return mc_dec128_modf_ex (d, NULL); +} + +/** + * @brief Compute the "fmod", the remainder after decimal division rounding + * towards zero. + * + * @param numer The dividend of the modulus + * @param denom The divisor of the modulus + * @param flags Control/status flags + */ +static inline mc_dec128 +mc_dec128_fmod_ex (mc_dec128 numer, mc_dec128 denom, mc_dec128_flagset *flags) +{ + extern mc_dec128 __mongocrypt_bid128_fmod ( + mc_dec128 numer, mc_dec128 denom, mc_dec128_flagset *); + mc_dec128_flagset zero_flags = {0}; + return __mongocrypt_bid128_fmod (numer, denom, flags ? flags : &zero_flags); +} + +/** + * @brief Compute the "fmod", the remainder after decimal division rounding + * towards zero. + * + * @param numer The dividend of the modulus + * @param denom The divisor of the modulus + */ +static inline mc_dec128 +mc_dec128_fmod (mc_dec128 numer, mc_dec128 denom) +{ + return mc_dec128_fmod_ex (numer, denom, NULL); +} + +/** + * @brief Obtain the a 64-bit binary integer value for the given Decimal128 + * value, nearest rounding toward zero. + * + * @param d The value to inspect + * @param flags Control/status flags + */ +static inline int64_t +mc_dec128_to_int64_ex (mc_dec128 d, mc_dec128_flagset *flags) +{ + extern int64_t __mongocrypt_bid128_to_int64_int (mc_dec128 d, + mc_dec128_flagset *); + mc_dec128_flagset zero_flags = {0}; + return __mongocrypt_bid128_to_int64_int (d, flags ? flags : &zero_flags); +} + +/** + * @brief Obtain the a 64-bit binary integer value for the given Decimal128 + * value, nearest rounding toward zero. + * + * @param d The value to inspect + */ +static inline int64_t +mc_dec128_to_int64 (mc_dec128 d) +{ + return mc_dec128_to_int64_ex (d, NULL); +} + +/// Constants for inspection/deconstruction of Decimal128 +enum { + /// Least non-canonical combination bits value + MC_DEC128_COMBO_NONCANONICAL = 3 << 15, + /// Least combination value indicating infinity + MC_DEC128_COMBO_INFINITY = 0x1e << 12, + /// The greatest Decimal128 biased exponent + MC_DEC128_MAX_BIASED_EXPONENT = 6143 + 6144, + /// The exponent bias of Decimal128 + MC_DEC128_EXPONENT_BIAS = 6143 + 33, // +33 to include the 34 decimal digits + /// Minimum exponent value (without bias) + MC_DEC_MIN_EXPONENT = -6143, + /// Maximum exponent value (without bias) + MC_DEC_MAX_EXPONENT = 6144, +}; + +/// Obtain the value of the combination bits of a decimal128 +static inline uint32_t +mc_dec128_combination (mc_dec128 d) +{ + // Grab the high 64 bits: + uint64_t hi = d._words[MLIB_IS_LITTLE_ENDIAN ? 1 : 0]; + // Sign is the 64th bit: + int signpos = 64 - 1; + // Combo is the next 16 bits: + int fieldpos = signpos - 17; + int fieldmask = (1 << 17) - 1; + return (uint32_t) ((hi >> fieldpos) & (uint32_t) fieldmask); +} + +/** + * @brief Obtain the value of the high 49 bits of the Decimal128 coefficient + */ +static inline uint64_t +mc_dec128_coeff_high (mc_dec128 d) +{ + uint64_t hi_field_mask = (1ull << 49) - 1; + uint32_t combo = mc_dec128_combination (d); + if (combo < MC_DEC128_COMBO_NONCANONICAL) { + uint64_t hi = d._words[MLIB_IS_LITTLE_ENDIAN ? 1 : 0]; + return hi & hi_field_mask; + } else { + return 0; + } +} + +/** + * @brief Obtain the value of the low 64 bits of the Decimal128 coefficient + */ +static inline uint64_t +mc_dec128_coeff_low (mc_dec128 d) +{ + uint32_t combo = mc_dec128_combination (d); + if (combo < MC_DEC128_COMBO_NONCANONICAL) { + uint64_t lo = d._words[MLIB_IS_LITTLE_ENDIAN ? 0 : 1]; + return lo; + } else { + return 0; + } +} + +/** + * @brief Obtain the full coefficient of the given Decimal128 number. Requires a + * 128-bit integer. + */ +static inline mlib_int128 +mc_dec128_coeff (mc_dec128 d) +{ + // Hi bits + uint64_t hi = mc_dec128_coeff_high (d); + // Lo bits + uint64_t lo = mc_dec128_coeff_low (d); + // Shift and add + mlib_int128 hi_128 = mlib_int128_lshift (MLIB_INT128_CAST (hi), 64); + return mlib_int128_add (hi_128, MLIB_INT128_CAST (lo)); +} + +/** + * @brief Obtain the biased value of the Decimal128 exponent. + * + * The value is "biased" in that its binary value not actually zero for 10^0. It + * is offset by half the exponent range (the "bias") so it can encode the full + * positive and negative exponent range. The bias value is defined as + * MC_DEC128_EXPONENT_BIAS. + */ +static inline uint32_t +mc_dec128_get_biased_exp (mc_dec128 d) +{ + uint32_t combo = mc_dec128_combination (d); + if (combo < MC_DEC128_COMBO_NONCANONICAL) { + return combo >> 3; + } + if (combo >= MC_DEC128_COMBO_INFINITY) { + return MC_DEC128_MAX_BIASED_EXPONENT + 1; + } else { + return (combo >> 1) & ((1 << 14) - 1); + } +} + +/// Create a decimal string from a dec128 number. The result must be freed. +static inline char * +mc_dec128_to_new_decimal_string (mc_dec128 d) +{ + if (mc_dec128_is_zero (d)) { + // Just return "0" + char *s = (char *) calloc (2, 1); + if (s) { + s[0] = '0'; + } + return s; + } + + if (mc_dec128_is_negative (d)) { + // Negate the result, return a string with a '-' prefix + d = mc_dec128_negate (d); + char *s = mc_dec128_to_new_decimal_string (d); + if (!s) { + return NULL; + } + char *s1 = (char *) calloc (strlen (s) + 2, 1); + if (s1) { + s1[0] = '-'; + strcpy (s1 + 1, s); + } + free (s); + return s1; + } + + if (mc_dec128_is_inf (d) || mc_dec128_is_nan (d)) { + const char *r = mc_dec128_is_inf (d) ? "Infinity" : "NaN"; + char *c = (char *) calloc (strlen (r) + 1, 1); + if (c) { + strcpy (c, r); + } + return c; + } + + const char DIGITS[] = "0123456789"; + const mc_dec128 TEN = MC_DEC128_C (10); + + // Format the whole and fractional part separately. + mc_dec128_modf_result modf = mc_dec128_modf (d); + + if (mc_dec128_is_zero (modf.frac)) { + // This is a non-zero integer + // Allocate enough digits: + mc_dec128 log10 = mc_dec128_modf (mc_dec128_log10 (d)).whole; + int64_t ndigits = mc_dec128_to_int64 (log10) + 1; + // +1 for null + char *strbuf = (char *) calloc ((size_t) (ndigits + 1), 1); + if (strbuf) { + // Write the string backwards: + char *optr = strbuf + ndigits - 1; + while (!mc_dec128_is_zero (modf.whole)) { + mc_dec128 rem = mc_dec128_fmod (modf.whole, TEN); + int64_t remi = mc_dec128_to_int64 (rem); + *optr-- = DIGITS[remi]; + // Divide ten + modf = mc_dec128_modf (mc_dec128_div (modf.whole, TEN)); + } + } + return strbuf; + } else if (mc_dec128_is_zero (modf.whole)) { + // This is only a fraction (less than one, but more than zero) + while (!mc_dec128_is_zero (mc_dec128_modf (d).frac)) { + d = mc_dec128_mul (d, TEN); + } + // 'd' is now a whole number + char *part = mc_dec128_to_new_decimal_string (d); + if (!part) { + return NULL; + } + char *buf = (char *) calloc (strlen (part) + 3, 1); + if (buf) { + buf[0] = '0'; + buf[1] = '.'; + strcpy (buf + 2, part); + } + free (part); + return buf; + } else { + // We have both a whole part and a fractional part + char *whole = mc_dec128_to_new_decimal_string (modf.whole); + if (!whole) { + return NULL; + } + char *frac = mc_dec128_to_new_decimal_string (modf.frac); + if (!frac) { + free (whole); + return NULL; + } + char *ret = (char *) calloc (strlen (whole) + strlen (frac) + 1, 1); + if (ret) { + char *out = ret; + strcpy (out, whole); + out += strlen (whole); + // "frac" contains a leading zero, which we don't want + strcpy (out, frac + 1); + } + free (whole); + free (frac); + return ret; + } +} + +static inline mc_dec128 +mc_dec128_from_bson_iter (bson_iter_t *it) +{ + bson_decimal128_t b; + if (!bson_iter_decimal128 (it, &b)) { + mc_dec128 nan = MC_DEC128_POSITIVE_NAN; + return nan; + } + mc_dec128 ret; + memcpy (&ret, &b, sizeof b); + return ret; +} + +static inline bson_decimal128_t +mc_dec128_to_bson_decimal128 (mc_dec128 v) +{ + bson_decimal128_t ret; + memcpy (&ret, &v, sizeof ret); + return ret; +} + +MLIB_C_LINKAGE_END + +#endif // MC_DEC128_H_INCLUDED diff --git a/src/mc-dec128.test.cpp b/src/mc-dec128.test.cpp new file mode 100644 index 000000000..b5bd0bebc --- /dev/null +++ b/src/mc-dec128.test.cpp @@ -0,0 +1,72 @@ +#include + +#include + +#include +#define CHECK MLIB_CHECK + +inline std::ostream & +operator<< (std::ostream &out, mc_dec128 d) noexcept +{ + auto s = mc_dec128_to_new_decimal_string (d); + out << s; + free (s); + return out; +} + +#define OPER(Op, Fn) \ + inline auto operator Op (mc_dec128 a, mc_dec128 b) noexcept /**/ \ + ->decltype (mc_dec128_##Fn (a, b)) \ + { \ + return mc_dec128_##Fn (a, b); \ + } + +OPER (+, add) +OPER (-, sub) +OPER (*, mul) +OPER (/, div) +OPER (==, equal) +OPER (>, greater) +OPER (<, less) + +int +main () +{ + mc_dec128 a = MC_DEC128_ZERO; + CHECK (mc_dec128_is_zero (a)); + + mc_dec128 b = MC_DEC128_ZERO; + mc_dec128 c = a * b; + CHECK (c == MC_DEC128_ZERO); + CHECK (mc_dec128_is_zero (c)); + + b = MC_DEC128_C (1); + // 0 + 1 = 1 + c = a + b; + CHECK (c == MC_DEC128_C (1)); + + // 1 + 1 = 2 + c = b + b; + CHECK (c == MC_DEC128_C (2)); + + // 2 * 2 = 4 + c = c * c; + CHECK (c == MC_DEC128_C (4)); + + // (4 + 1) / 2 = 2.5 + c = (c + MC_DEC128_C (1)) / MC_DEC128_C (2); + CHECK (c == mc_dec128_from_string ("2.5")); + + mc_dec128_string s = mc_dec128_to_string (c); + CHECK (std::string (s.str) == "+25E-1"); + + char *str = mc_dec128_to_new_decimal_string (c); + CHECK (std::string (str) == "2.5"); + free (str); + + mc_dec128 infin = MC_DEC128_POSITIVE_INFINITY; + CHECK (mc_dec128_is_inf (infin)); + + mc_dec128 nan = MC_DEC128_POSITIVE_NAN; + CHECK (mc_dec128_is_nan (nan)); +} diff --git a/src/mc-fle2-payload-iev.c b/src/mc-fle2-payload-iev.c index 2f8767cf0..c71404270 100644 --- a/src/mc-fle2-payload-iev.c +++ b/src/mc-fle2-payload-iev.c @@ -229,7 +229,7 @@ mc_FLE2IndexedEncryptedValue_decrypt ( mc_reader_get_consumed_length (&reader) + length - 16; if (length > iev->Inner.len || expected_length > iev->Inner.len) { CLIENT_ERR ("mc_FLE2IndexedEncryptedValue_add_S_Key expected " - "byte length >= %" PRIu32 " got: %" PRIu32, + "byte length >= %" PRIu64 " got: %" PRIu32, expected_length, iev->Inner.len); return false; diff --git a/src/mc-optional-private.h b/src/mc-optional-private.h index 3ce6a0b26..506fd0637 100644 --- a/src/mc-optional-private.h +++ b/src/mc-optional-private.h @@ -20,6 +20,9 @@ #include #include +#include "./mc-dec128.h" +#include "./mlib/int128.h" + typedef struct { bool set; int32_t value; @@ -100,4 +103,21 @@ typedef struct { .set = true, .value = val \ } +typedef struct { + bool set; + mc_dec128 value; +} mc_optional_dec128_t; + +#define OPT_MC_DEC128(...) \ + (mc_optional_dec128_t) \ + { \ + .set = true, .value = __VA_ARGS__ \ + } + + +#define OPT_NULLOPT \ + { \ + .set = false \ + } + #endif /* MC_OPTIONAL_PRIVATE_H */ diff --git a/src/mc-range-edge-generation-private.h b/src/mc-range-edge-generation-private.h index 033a9f5f8..865ff7a88 100644 --- a/src/mc-range-edge-generation-private.h +++ b/src/mc-range-edge-generation-private.h @@ -21,6 +21,8 @@ #include #include "mc-optional-private.h" #include "mongocrypt-status-private.h" +#include "mc-dec128.h" +#include // mc_edges_t represents a list of edges. typedef struct _mc_edges_t mc_edges_t; @@ -75,24 +77,87 @@ typedef struct { mc_edges_t * mc_getEdgesDouble (mc_getEdgesDouble_args_t args, mongocrypt_status_t *status); +typedef struct { + mc_dec128 value; + size_t sparsity; + mc_optional_dec128_t min, max; + mc_optional_uint32_t precision; +} mc_getEdgesDecimal128_args_t; + +mc_edges_t * +mc_getEdgesDecimal128 (mc_getEdgesDecimal128_args_t args, + mongocrypt_status_t *status); + + // count_leading_zeros_u64 returns the number of leading 0 bits of `in`. -size_t -mc_count_leading_zeros_u64 (uint64_t in); +static inline size_t +mc_count_leading_zeros_u64 (uint64_t in) +{ +#ifdef __has_builtin +#if __has_builtin(__builtin_clzl) +// Pointer-cast to ensure we are speaking the right type +#ifdef __APPLE__ + unsigned long long *p = ∈ + return (size_t) (in ? __builtin_clzll (*p) : 64); +#else + unsigned long *p = ∈ + return (size_t) (in ? __builtin_clzl (*p) : 64); +#endif +#endif +#endif + uint64_t bit = UINT64_C (1) << 63; + size_t count = 0; + while ((bit & in) == 0 && bit > 0) { + bit >>= 1; + ++count; + } + return count; +} // count_leading_zeros_u32 returns the number of leading 0 bits of `in`. -size_t -mc_count_leading_zeros_u32 (uint32_t in); +static inline size_t +mc_count_leading_zeros_u32 (uint32_t in) +{ +#ifdef __has_builtin +#if __has_builtin(__builtin_clz) + // Pointer-cast to ensure we are speaking the right type + unsigned int *p = ∈ + return (size_t) (in ? __builtin_clz (*p) : 32); +#endif +#endif + uint32_t bit = UINT32_C (1) << 31; + int count = 0; + while ((bit & in) == 0 && bit > 0) { + bit >>= 1; + ++count; + } + return (size_t) count; +} + +static inline size_t +mc_count_leading_zeros_u128 (mlib_int128 in) +{ + size_t hi = mc_count_leading_zeros_u64 ( + mlib_int128_to_u64 (mlib_int128_rshift (in, 64))); + size_t lo = mc_count_leading_zeros_u64 (mlib_int128_to_u64 (in)); + return hi + ((hi == 64 ? 1u : 0u) * lo); +} + +typedef struct mc_bitstring { + char str[129]; +} mc_bitstring; // mc_convert_to_bitstring_u64 returns a 64 character string of 1's and 0's -// representing the bits of `in`. Caller must call `bson_free` on returned -// value. -char * +// representing the bits of `in` +mc_bitstring mc_convert_to_bitstring_u64 (uint64_t in); // mc_convert_to_bitstring_u32 returns a 32 character string of 1's and 0's -// representing the bits of `in`. Caller must call `bson_free` on returned -// value. -char * +// representing the bits of `in`. +mc_bitstring mc_convert_to_bitstring_u32 (uint32_t in); +mc_bitstring +mc_convert_to_bitstring_u128 (mlib_int128 i); + #endif /* MC_RANGE_EDGE_GENERATION_PRIVATE_H */ diff --git a/src/mc-range-edge-generation.c b/src/mc-range-edge-generation.c index 5faffb552..caa7e65b2 100644 --- a/src/mc-range-edge-generation.c +++ b/src/mc-range-edge-generation.c @@ -89,66 +89,53 @@ mc_edges_destroy (mc_edges_t *edges) bson_free (edges); } -size_t -mc_count_leading_zeros_u64 (uint64_t in) -{ - uint64_t bit = UINT64_C (1) << 63; - size_t count = 0; - while ((bit & in) == 0 && bit > 0) { - bit >>= 1; - ++count; - } - return count; -} - -size_t -mc_count_leading_zeros_u32 (uint32_t in) -{ - uint32_t bit = UINT32_C (1) << 31; - size_t count = 0; - while ((bit & in) == 0 && bit > 0) { - bit >>= 1; - ++count; - } - return count; -} - -char * +mc_bitstring mc_convert_to_bitstring_u64 (uint64_t in) { - char *out = bson_malloc (64 + 1); + mc_bitstring ret = {{0}}; + char *out = ret.str; uint64_t bit = UINT64_C (1) << 63; - size_t count = 0; while (bit > 0) { if (bit & in) { - out[count] = '1'; + *out++ = '1'; } else { - out[count] = '0'; + *out++ = '0'; } bit >>= 1; - ++count; } - out[64] = '\0'; - return out; + return ret; } -char * +mc_bitstring mc_convert_to_bitstring_u32 (uint32_t in) { - char *out = bson_malloc (32 + 1); + mc_bitstring ret = {{0}}; + char *out = ret.str; uint32_t bit = UINT32_C (1) << 31; - size_t count = 0; while (bit > 0) { if (bit & in) { - out[count] = '1'; + *out++ = '1'; } else { - out[count] = '0'; + *out++ = '0'; } bit >>= 1; - ++count; } - out[32] = '\0'; - return out; + return ret; +} + +mc_bitstring +mc_convert_to_bitstring_u128 (mlib_int128 i) +{ + const uint64_t lo = mlib_int128_to_u64 (i); + const uint64_t hi = mlib_int128_to_u64 (mlib_int128_rshift (i, 64)); + mc_bitstring his = mc_convert_to_bitstring_u64 (hi); + mc_bitstring los = mc_convert_to_bitstring_u64 (lo); + mc_bitstring ret = {{0}}; + const size_t off = + mlib_strnmcopy (ret.str, sizeof ret.str, his.str, sizeof his.str); + mlib_strnmcopy ( + ret.str + off, (sizeof ret.str) - off, los.str, sizeof los.str); + return ret; } mc_edges_t * @@ -168,11 +155,10 @@ mc_getEdgesInt32 (mc_getEdgesInt32_args_t args, mongocrypt_status_t *status) // for consistency with the server implementation. BSON_ASSERT (got.min == 0); - char *valueBin = mc_convert_to_bitstring_u32 (got.value); + mc_bitstring valueBin = mc_convert_to_bitstring_u32 (got.value); size_t offset = mc_count_leading_zeros_u32 (got.max); - const char *leaf = valueBin + offset; + const char *leaf = valueBin.str + offset; mc_edges_t *ret = mc_edges_new (leaf, args.sparsity, status); - bson_free (valueBin); return ret; } @@ -193,11 +179,10 @@ mc_getEdgesInt64 (mc_getEdgesInt64_args_t args, mongocrypt_status_t *status) // for consistency with the server implementation. BSON_ASSERT (got.min == 0); - char *valueBin = mc_convert_to_bitstring_u64 (got.value); + mc_bitstring valueBin = mc_convert_to_bitstring_u64 (got.value); size_t offset = mc_count_leading_zeros_u64 (got.max); - const char *leaf = valueBin + offset; + const char *leaf = valueBin.str + offset; mc_edges_t *ret = mc_edges_new (leaf, args.sparsity, status); - bson_free (valueBin); return ret; } @@ -221,10 +206,35 @@ mc_getEdgesDouble (mc_getEdgesDouble_args_t args, mongocrypt_status_t *status) // for consistency with the server implementation. BSON_ASSERT (got.min == 0); - char *valueBin = mc_convert_to_bitstring_u64 (got.value); + mc_bitstring valueBin = mc_convert_to_bitstring_u64 (got.value); size_t offset = mc_count_leading_zeros_u64 (got.max); - const char *leaf = valueBin + offset; + const char *leaf = valueBin.str + offset; + mc_edges_t *ret = mc_edges_new (leaf, args.sparsity, status); + return ret; +} + +mc_edges_t * +mc_getEdgesDecimal128 (mc_getEdgesDecimal128_args_t args, + mongocrypt_status_t *status) +{ + mc_OSTType_Decimal128 got; + if (!mc_getTypeInfoDecimal128 ( + (mc_getTypeInfoDecimal128_args_t){ + .value = args.value, + .min = args.min, + .max = args.max, + .precision = args.precision, + }, + &got, + status)) { + return NULL; + } + + BSON_ASSERT (mlib_int128_eq (got.min, MLIB_INT128 (0))); + + mc_bitstring bits = mc_convert_to_bitstring_u128 (got.value); + size_t offset = mc_count_leading_zeros_u128 (got.max); + const char *leaf = bits.str + offset; mc_edges_t *ret = mc_edges_new (leaf, args.sparsity, status); - bson_free (valueBin); return ret; } diff --git a/src/mc-range-encoding-private.h b/src/mc-range-encoding-private.h index b96f2dfd5..96840f558 100644 --- a/src/mc-range-encoding-private.h +++ b/src/mc-range-encoding-private.h @@ -17,10 +17,14 @@ #ifndef MC_RANGE_ENCODING_PRIVATE_H #define MC_RANGE_ENCODING_PRIVATE_H -#include #include "mc-optional-private.h" +#include "mc-dec128.h" #include "mongocrypt-status-private.h" +#include + +#include + /* mc-range-encoding-private.h has functions to encode numeric types for * Queryable Encryption Range queries. It is a translation from server code: * https://github.com/mongodb/mongo/blob/1364f5c5004ac5503837ac5b315c189625f97269/src/mongo/crypto/fle_crypto.h#L1194-L1196 @@ -92,4 +96,31 @@ mc_getTypeInfoDouble (mc_getTypeInfoDouble_args_t args, mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT; +/** + * @brief OST-encoding of a Decimal128 + */ +typedef struct { + mlib_int128 value, min, max; +} mc_OSTType_Decimal128; + +typedef struct { + mc_dec128 value; + mc_optional_dec128_t min, max; + mc_optional_uint32_t precision; +} mc_getTypeInfoDecimal128_args_t; + +/** + * @brief Obtain the OST encoding of a finite Decimal128 value. + * + * @param out Output for the result + * @param status Output for status on error + * @retval true On success + * @retval false Otherwise + */ +bool +mc_getTypeInfoDecimal128 (mc_getTypeInfoDecimal128_args_t args, + mc_OSTType_Decimal128 *out, + mongocrypt_status_t *status) + MONGOCRYPT_WARN_UNUSED_RESULT; + #endif /* MC_RANGE_ENCODING_PRIVATE_H */ diff --git a/src/mc-range-encoding.c b/src/mc-range-encoding.c index 0d95218e6..24cf0fdd6 100644 --- a/src/mc-range-encoding.c +++ b/src/mc-range-encoding.c @@ -230,7 +230,7 @@ mc_getTypeInfoDouble (mc_getTypeInfoDouble_args_t args, uint32_t bits_range; if (args.precision.set) { // Subnormal representations can support up to 5x10^-324 as a number - if (args.precision.value < 0 || args.precision.value > 324) { + if (args.precision.value > 324) { CLIENT_ERR ( "Precision must be between 0 and 324 inclusive, got: %" PRIu32, args.precision.value); @@ -313,3 +313,303 @@ mc_getTypeInfoDouble (mc_getTypeInfoDouble_args_t args, return true; } + +/** + * @brief There is no shipped algorithm for creating a full 128-bit integer from + * a Decimal128, but it's easy enough to write one of our own. + * + * @param dec + * @return mlib_int128 + */ +static mlib_int128 +dec128_to_int128 (mc_dec128 dec) +{ + // Only normal numbers + BSON_ASSERT (mc_dec128_is_finite (dec)); + BSON_ASSERT (!mc_dec128_is_nan (dec)); + // We don't support negative numbers + BSON_ASSERT (!mc_dec128_is_negative (dec)); + // There is no fractional part: + BSON_ASSERT (mc_dec128_is_zero (mc_dec128_modf (dec).frac)); + + mlib_int128 ret = mc_dec128_coeff (dec); + + // Scale the resulting number by a power of ten matching the exponent of the + // Decimal128: + int32_t exp = + ((int32_t) mc_dec128_get_biased_exp (dec)) - MC_DEC128_EXPONENT_BIAS; + // We will scale up/down based on whether it is negative: + mlib_int128 e1 = mlib_int128_pow10 ((uint8_t) abs (exp)); + if (exp < 0) { + ret = mlib_int128_div (ret, e1); + } else { + ret = mlib_int128_mul (ret, e1); + } + + return ret; +} + +bool +mc_getTypeInfoDecimal128 (mc_getTypeInfoDecimal128_args_t args, + mc_OSTType_Decimal128 *out, + mongocrypt_status_t *status) +{ + /// Basic param checks + if (args.min.set != args.max.set || args.min.set != args.precision.set) { + CLIENT_ERR ( + "min, max, and precision must all be set or must all be unset"); + return false; + } + + // We only accept normal numbers + if (mc_dec128_is_inf (args.value) || mc_dec128_is_nan (args.value)) { + CLIENT_ERR ("Infinity and Nan Decimal128 values are not supported."); + return false; + } + + // Check boundary if a range is set + if (args.min.set) { + // [min,max] must be valid + if (mc_dec128_greater_equal (args.min.value, args.max.value)) { + CLIENT_ERR ( + "The minimum value must be less than the maximum value, got " + "min: %s, max: %s", + mc_dec128_to_string (args.min.value).str, + mc_dec128_to_string (args.max.value).str); + return false; + } + + // Value must be within [min,max) + if (mc_dec128_greater (args.value, args.max.value) || + mc_dec128_less (args.value, args.min.value)) { + CLIENT_ERR ("Value must be greater than or equal to the minimum value " + "and less than or equal to the maximum value, got " + "min: %s, max: %s, value: %s", + mc_dec128_to_string (args.min.value).str, + mc_dec128_to_string (args.max.value).str, + mc_dec128_to_string (args.value).str); + return false; + } + } + + // Should we use precision mode? + // + // When we use precision mode, we try to represent as a decimal128 value that + // fits in [-2^127, 2^127] (i.e. is a valid int128) + // + // This check determines if we can represent any precision-truncated value as + // a 128-bit integer I.e. Is ((ub - lb) * 10^precision) < 128 bits. + // + // It is important that we determine whether a range and its precision would + // fit, regardless of the value to be encoded, because the encoding for + // precision-truncated-decimal128 is incompatible with the encoding of the + // full range. + bool use_precision_mode = false; + // The number of bits required to hold the result (used for precision mode) + uint8_t bits_range = 0; + if (args.precision.set) { + // Subnormal representations can support up to 5x10^-6182 as a number + if (args.precision.value > 6182) { + CLIENT_ERR ( + "Precision must be between 0 and 6182 inclusive, got: %" PRIu32, + args.precision.value); + return false; + } + + // max - min + mc_dec128 bounds_n1 = mc_dec128_sub (args.max.value, args.min.value); + // The size of [min, max]: (max - min) + 1 + mc_dec128 bounds = mc_dec128_add (bounds_n1, MC_DEC128_ONE); + + // We can overflow if max = max_dec128 and min = min_dec128 so make sure + // we have finite number after we do subtraction + if (mc_dec128_is_finite (bounds)) { + // This creates a range which is wider then we permit by our min/max + // bounds check with the +1 but it is as the algorithm is written in + // WRITING-11907. + mc_dec128 precision_scaled_bounds = + mc_dec128_scale (bounds, args.precision.value); + /// The number of bits required to hold the result for the given + /// precision (as decimal) + mc_dec128 bits_range_dec = mc_dec128_log2 (precision_scaled_bounds); + + if (mc_dec128_is_finite (bits_range_dec) && + mc_dec128_less (bits_range_dec, MC_DEC128 (128))) { + // We need fewer than 128 bits to hold the result. But round up, + // just to be sure: + int64_t r = mc_dec128_to_int64 ( + mc_dec128_round_integral_positive (bits_range_dec)); + BSON_ASSERT (r >= 0); + BSON_ASSERT (r <= UINT8_MAX); + // We've computed the proper 'bits_range' + bits_range = (uint8_t) r; + + if (bits_range < 128) { + use_precision_mode = true; + } + } + } + } + + // Constant zero + const mlib_int128 i128_zero = MLIB_INT128 (0); + // Constant 1 + const mlib_int128 i128_one = MLIB_INT128 (1); + // Constant 10 + const mlib_int128 i128_ten = MLIB_INT128 (10); + // Constant: 2^127 + const mlib_int128 i128_2pow127 = mlib_int128_lshift (i128_one, 127); + // ↑ Coincidentally has the same bit pattern as INT128_SMIN, but we're + // treating it as an unsigned number here, so don't get confused! + + if (use_precision_mode) { + BSON_ASSERT (args.precision.set); + // Example value: 31.4159 + // Example Precision = 2 + + // Shift the number up + // Returns: 3141.9 + mc_dec128 valScaled = mc_dec128_scale (args.value, args.precision.value); + + // Round the number down + // Returns 3141.0 + mc_dec128 valTrunc = mc_dec128_round_integral_zero (valScaled); + + // Shift the number down + // Returns: 31.41 + mc_dec128 v_prime = + mc_dec128_scale (valTrunc, -(int32_t) args.precision.value); + + // Adjust the number by the lower bound + // Make it an integer by scaling the number + // + // Returns 3141.0 + mc_dec128 v_prime2 = mc_dec128_scale ( + mc_dec128_sub (v_prime, args.min.value), args.precision.value); + // Round the number down again. min may have a fractional value with more + // decimal places than the precision (e.g. .001). Subtracting min may have + // resulted in v_prime2 with a non-zero fraction. v_prime2 is expected to + // have no fractional value when converting to int128. + v_prime2 = mc_dec128_round_integral_zero (v_prime2); + + BSON_ASSERT (mc_dec128_less (mc_dec128_log2 (v_prime2), MC_DEC128 (128))); + + // Resulting OST maximum + mlib_int128 ost_max = + mlib_int128_sub (mlib_int128_pow2 (bits_range), i128_one); + + // Now we need to get the Decimal128 out as a 128-bit integer + // But Decimal128 does not support conversion to Int128. + // + // If we think the Decimal128 fits in the range, based on the maximum + // value, we try to convert to int64 directly. + if (bits_range < 64) { + // Try conversion to int64, it may fail but since it is easy we try + // this first. + mc_dec128_flagset flags = {0}; + int64_t as64 = mc_dec128_to_int64_ex (v_prime2, &flags); + if (flags.bits == 0) { + // No error. It fits + *out = (mc_OSTType_Decimal128){ + .value = MLIB_INT128_CAST (as64), + .min = i128_zero, + .max = ost_max, + }; + return true; + } else { + // Conversion failure to 64-bit. Possible overflow, imprecision, + // etc. Fallback to slower dec128_to_int128 + } + } + + mlib_int128 u_ret = dec128_to_int128 (v_prime2); + + *out = (mc_OSTType_Decimal128){ + .value = u_ret, + .min = i128_zero, + .max = ost_max, + }; + + return true; + } + + // The coefficient of the number, without exponent/sign + const mlib_int128 coeff = mc_dec128_coeff (args.value); + + if (mlib_int128_eq (coeff, i128_zero)) { + // If the coefficient is zero, the result is encoded as the midpoint + // between zero and 2^128-1 + *out = (mc_OSTType_Decimal128){ + .value = i128_2pow127, + .min = i128_zero, + .max = MLIB_INT128_UMAX, + }; + return true; + } + + // Coefficient is an unsigned value. We'll later scale our answer based on + // the sign of the actual Decimal128 + const bool isNegative = mc_dec128_is_negative (args.value); + + // cMax = 10^34 - 1 (The largest integer representable in Decimal128) + const mlib_int128 cMax = + mlib_int128_sub (mlib_int128_pow10 (34), MLIB_INT128_CAST (1)); + const mlib_int128 cMax_div_ten = mlib_int128_div (cMax, i128_ten); + + // The biased exponent from the decimal number. The paper refers to the + // expression (e - e_min), which is the value of the biased exponent. + const uint32_t exp_biased = mc_dec128_get_biased_exp (args.value); + + // ρ (rho) is the greatest integer such that: coeff×10^ρ <= cMax + unsigned rho = 0; + // Keep track of the subexpression coeff×10^ρ rather than recalculating it + // time. + // Initially: (ρ = 0) -> (10^ρ = 1) -> (coeff×10^ρ = coeff×1 = coeff): + mlib_int128 coeff_scaled = coeff; + // Calculate ρ: This could be done using a log10 with a division, but that + // is far more work than just a few multiplications. + // While: coeff×ten^ρ < cMax/10: + while (mlib_int128_ucmp (coeff_scaled, cMax_div_ten) < 0) { + // Increase rho until we pass cMax/10 + rho++; + // Scale our computed subexpression rather than fully recomputing it + coeff_scaled = mlib_int128_mul (coeff_scaled, i128_ten); + } + + // No multiplication by 10 should ever send us from N < cMax/10 to N > cMax + BSON_ASSERT (mlib_int128_ucmp (coeff_scaled, cMax) <= 0); + + mlib_int128 result; + if (rho <= exp_biased) { + // ρ is less-than/equal to the exponent with bias. + + // Diff between the biased exponent and ρ. + // Value in paper is spelled "e - e_min - ρ" + const uint32_t exp_diff = exp_biased - (uint32_t) rho; + // cMax * (exp_diff) + const mlib_int128 cmax_scaled = + mlib_int128_mul (cMax, MLIB_INT128_CAST (exp_diff)); + // coeff * 10^rho * cMax * (exp_biased - rho) + result = mlib_int128_add (coeff_scaled, cmax_scaled); + } else { + const mlib_int128 biased_scale = mlib_int128_pow10 ((uint8_t) exp_biased); + result = mlib_int128_mul (biased_scale, coeff); + } + + // Always add 2^127: + result = mlib_int128_add (result, i128_2pow127); + + if (isNegative) { + // We calculated the value of the positive coefficient, but the decimal is + // negative. That's okay: Just flip the sign of the encoded result: + result = mlib_int128_negate (result); + } + + *out = (mc_OSTType_Decimal128){ + .value = result, + .min = i128_zero, + .max = MLIB_INT128_UMAX, + }; + + return true; +} diff --git a/src/mc-range-mincover-generator.template.h b/src/mc-range-mincover-generator.template.h index 9b348a156..54fa345ae 100644 --- a/src/mc-range-mincover-generator.template.h +++ b/src/mc-range-mincover-generator.template.h @@ -16,9 +16,6 @@ // mc-range-mincover-generator.template.h is meant to be included in another // source file. -#ifndef BITS -#error "must be included with BITS defined" -#endif // TODO: replace `CONCAT` with `BSON_CONCAT` after libbson dependency is // upgraded to 1.20.0 or higher. @@ -32,11 +29,75 @@ #define CONCAT3(a, b, c) CONCAT (a, CONCAT (b, c)) #endif -#define UINT_T CONCAT3 (uint, BITS, _t) -#define UINT_C CONCAT3 (UINT, BITS, _C) -#define FMT_UINT_T CONCAT (PRId, BITS) -#define WITH_BITS(X) CONCAT3 (X, _u, BITS) +#if !(defined(UINT_T) && defined(UINT_C) && defined(UINT_FMT_S) && \ + defined(DECORATE_NAME)) +#ifdef __INTELLISENSE__ +#define UINT_T uint32_t +#define UINT_C UINT32_C +#define UINT_FMT_S PRIu32 +#define DECORATE_NAME(Name) Name##_u32 +#else +#error All of UINT_T, UINT_C, UINT_FMT_S, UINT_FMT_ARG, and DECORATE_NAME must be defined before #including this file +#endif +#endif + +#define BITS (sizeof (UINT_T) * CHAR_BIT) + +#define ZERO UINT_C (0) + +// Default for UINT_FMT_ARG +#ifndef UINT_FMT_ARG +#define UINT_FMT_ARG(X) X +#endif + +// Default comparison +#ifndef UINT_LESSTHAN +#define UINT_LESSTHAN(A, B) ((A) < (B)) +#endif +#ifndef MC_UINT_MAX +#define MC_UINT_MAX ~(UINT_C (0)) +#endif + +// Default addition +#ifndef UINT_ADD +#define UINT_ADD(A, B) ((A) + (B)) +#endif +#ifndef UINT_SUB +#define UINT_SUB(A, B) ((A) - (B)) +#endif + +// Default lshift (also handles negatives as right-shift) +#ifndef UINT_LSHIFT +static inline UINT_T +DECORATE_NAME (_mc_default_lshift) (UINT_T lhs, int off) +{ + if (off < 0) { + return lhs >> -off; + } else { + return lhs << off; + } +} +#define UINT_LSHIFT DECORATE_NAME (_mc_default_lshift) +#endif + +#ifndef UINT_BITOR +#define UINT_BITOR(A, B) ((A) | (B)) +#endif + +static inline int +DECORATE_NAME (_mc_compare) (UINT_T lhs, UINT_T rhs) +{ + if (UINT_LESSTHAN (lhs, rhs)) { + return -1; + } else if (UINT_LESSTHAN (rhs, lhs)) { + return 1; + } else { + return 0; + } +} + +#define UINT_COMPARE DECORATE_NAME (_mc_compare) // MinCoverGenerator models the MinCoverGenerator type added in // SERVER-68600. @@ -46,31 +107,31 @@ typedef struct { size_t _sparsity; // _maxlen is the maximum bit length of edges in the mincover. size_t _maxlen; -} WITH_BITS (MinCoverGenerator); - -static inline WITH_BITS (MinCoverGenerator) * - WITH_BITS (MinCoverGenerator_new) (UINT_T rangeMin, - UINT_T rangeMax, - UINT_T max, - size_t sparsity, - mongocrypt_status_t *status) +} DECORATE_NAME (MinCoverGenerator); + +static inline DECORATE_NAME (MinCoverGenerator) * + DECORATE_NAME (MinCoverGenerator_new) (UINT_T rangeMin, + UINT_T rangeMax, + UINT_T max, + size_t sparsity, + mongocrypt_status_t *status) { BSON_ASSERT_PARAM (status); - if (rangeMin > rangeMax) { - CLIENT_ERR ("Range min (%" FMT_UINT_T - ") must be less than or equal to range max (%" FMT_UINT_T + if (UINT_COMPARE (rangeMin, rangeMax) > 0) { + CLIENT_ERR ("Range min (%" UINT_FMT_S + ") must be less than or equal to range max (%" UINT_FMT_S ") for range search", - rangeMin, - rangeMax); + UINT_FMT_ARG (rangeMin), + UINT_FMT_ARG (rangeMax)); return NULL; } - if (rangeMax > max) { - CLIENT_ERR ("Range max (%" FMT_UINT_T - ") must be less than or equal to max (%" FMT_UINT_T + if (UINT_COMPARE (rangeMax, max) > 0) { + CLIENT_ERR ("Range max (%" UINT_FMT_S + ") must be less than or equal to max (%" UINT_FMT_S ") for range search", - rangeMax, - max); + UINT_FMT_ARG (rangeMax), + UINT_FMT_ARG (max)); return NULL; } @@ -78,17 +139,18 @@ static inline WITH_BITS (MinCoverGenerator) * CLIENT_ERR ("Sparsity must be > 0"); return NULL; } - WITH_BITS (MinCoverGenerator) *mcg = - bson_malloc0 (sizeof (WITH_BITS (MinCoverGenerator))); + DECORATE_NAME (MinCoverGenerator) *mcg = + bson_malloc0 (sizeof (DECORATE_NAME (MinCoverGenerator))); mcg->_rangeMin = rangeMin; mcg->_rangeMax = rangeMax; - mcg->_maxlen = (size_t) BITS - WITH_BITS (mc_count_leading_zeros) (max); + mcg->_maxlen = (size_t) BITS - DECORATE_NAME (mc_count_leading_zeros) (max); mcg->_sparsity = sparsity; return mcg; } static inline void -WITH_BITS (MinCoverGenerator_destroy) (WITH_BITS (MinCoverGenerator) * mcg) +DECORATE_NAME (MinCoverGenerator_destroy) (DECORATE_NAME (MinCoverGenerator) * + mcg) { bson_free (mcg); } @@ -96,9 +158,9 @@ WITH_BITS (MinCoverGenerator_destroy) (WITH_BITS (MinCoverGenerator) * mcg) // applyMask applies a mask of 1 bits starting from the right. // Bits 0 to bit-1 are replaced with 1. Other bits are left as-is. static inline UINT_T -WITH_BITS (applyMask) (UINT_T value, size_t maskedBits) +DECORATE_NAME (applyMask) (UINT_T value, size_t maskedBits) { - const UINT_T ones = ~UINT_C (0); + const UINT_T ones = MC_UINT_MAX; BSON_ASSERT (maskedBits <= (size_t) BITS); BSON_ASSERT (maskedBits >= 0); @@ -108,14 +170,13 @@ WITH_BITS (applyMask) (UINT_T value, size_t maskedBits) } const size_t shift = ((size_t) BITS - maskedBits); - const UINT_T mask = ones >> shift; - return value | mask; + const UINT_T mask = UINT_LSHIFT (ones, -(int) shift); + return UINT_BITOR (value, mask); } static inline bool -WITH_BITS (MinCoverGenerator_isLevelStored) (WITH_BITS (MinCoverGenerator) * - mcg, - size_t maskedBits) +DECORATE_NAME (MinCoverGenerator_isLevelStored) ( + DECORATE_NAME (MinCoverGenerator) * mcg, size_t maskedBits) { BSON_ASSERT_PARAM (mcg); size_t level = mcg->_maxlen - maskedBits; @@ -123,9 +184,8 @@ WITH_BITS (MinCoverGenerator_isLevelStored) (WITH_BITS (MinCoverGenerator) * } char * -WITH_BITS (MinCoverGenerator_toString) (WITH_BITS (MinCoverGenerator) * mcg, - UINT_T start, - size_t maskedBits) +DECORATE_NAME (MinCoverGenerator_toString) ( + DECORATE_NAME (MinCoverGenerator) * mcg, UINT_T start, size_t maskedBits) { BSON_ASSERT_PARAM (mcg); BSON_ASSERT (maskedBits <= mcg->_maxlen); @@ -136,33 +196,35 @@ WITH_BITS (MinCoverGenerator_toString) (WITH_BITS (MinCoverGenerator) * mcg, return bson_strdup ("root"); } - UINT_T shifted = start >> maskedBits; - char *valueBin = WITH_BITS (mc_convert_to_bitstring) (shifted); + UINT_T shifted = UINT_LSHIFT (start, -(int) maskedBits); + mc_bitstring valueBin = DECORATE_NAME (mc_convert_to_bitstring) (shifted); char *ret = - bson_strndup (valueBin + ((size_t) BITS - mcg->_maxlen + maskedBits), + bson_strndup (valueBin.str + ((size_t) BITS - mcg->_maxlen + maskedBits), mcg->_maxlen + maskedBits); - bson_free (valueBin); return ret; } static inline void -WITH_BITS (MinCoverGenerator_minCoverRec) (WITH_BITS (MinCoverGenerator) * mcg, - mc_array_t *c, - UINT_T blockStart, - size_t maskedBits) +DECORATE_NAME (MinCoverGenerator_minCoverRec) ( + DECORATE_NAME (MinCoverGenerator) * mcg, + mc_array_t *c, + UINT_T blockStart, + size_t maskedBits) { BSON_ASSERT_PARAM (mcg); BSON_ASSERT_PARAM (c); - const UINT_T blockEnd = WITH_BITS (applyMask) (blockStart, maskedBits); + const UINT_T blockEnd = DECORATE_NAME (applyMask) (blockStart, maskedBits); - if (blockEnd < mcg->_rangeMin || blockStart > mcg->_rangeMax) { + if (UINT_COMPARE (blockEnd, mcg->_rangeMin) < 0 || + UINT_COMPARE (blockStart, mcg->_rangeMax) > 0) { return; } - if (blockStart >= mcg->_rangeMin && blockEnd <= mcg->_rangeMax && - WITH_BITS (MinCoverGenerator_isLevelStored) (mcg, maskedBits)) { - char *edge = - WITH_BITS (MinCoverGenerator_toString) (mcg, blockStart, maskedBits); + if (UINT_COMPARE (blockStart, mcg->_rangeMin) >= 0 && + UINT_COMPARE (blockEnd, mcg->_rangeMax) <= 0 && + DECORATE_NAME (MinCoverGenerator_isLevelStored) (mcg, maskedBits)) { + char *edge = DECORATE_NAME (MinCoverGenerator_toString) ( + mcg, blockStart, maskedBits); _mc_array_append_val (c, edge); return; } @@ -170,18 +232,22 @@ WITH_BITS (MinCoverGenerator_minCoverRec) (WITH_BITS (MinCoverGenerator) * mcg, BSON_ASSERT (maskedBits > 0); const size_t newBits = maskedBits - 1u; - WITH_BITS (MinCoverGenerator_minCoverRec) (mcg, c, blockStart, newBits); - WITH_BITS (MinCoverGenerator_minCoverRec) - (mcg, c, blockStart | UINT_C (1) << newBits, newBits); + DECORATE_NAME (MinCoverGenerator_minCoverRec) (mcg, c, blockStart, newBits); + DECORATE_NAME (MinCoverGenerator_minCoverRec) + (mcg, + c, + UINT_BITOR (blockStart, UINT_LSHIFT (UINT_C (1), (int) newBits)), + newBits); } static inline mc_mincover_t * -WITH_BITS (MinCoverGenerator_minCover) (WITH_BITS (MinCoverGenerator) * mcg) +DECORATE_NAME (MinCoverGenerator_minCover) (DECORATE_NAME (MinCoverGenerator) * + mcg) { BSON_ASSERT_PARAM (mcg); mc_mincover_t *mc = mc_mincover_new (); - WITH_BITS (MinCoverGenerator_minCoverRec) - (mcg, &mc->mincover, 0, mcg->_maxlen); + DECORATE_NAME (MinCoverGenerator_minCoverRec) + (mcg, &mc->mincover, ZERO, mcg->_maxlen); return mc; } @@ -190,43 +256,53 @@ WITH_BITS (MinCoverGenerator_minCover) (WITH_BITS (MinCoverGenerator) * mcg) // lowerBound, min, upperBound, and max are expected to come from the result // of mc_getTypeInfo. static bool -WITH_BITS (adjustBounds) (UINT_T *lowerBound, - bool includeLowerBound, - UINT_T min, - UINT_T *upperBound, - bool includeUpperBound, - UINT_T max, - mongocrypt_status_t *status) +DECORATE_NAME (adjustBounds) (UINT_T *lowerBound, + bool includeLowerBound, + UINT_T min, + UINT_T *upperBound, + bool includeUpperBound, + UINT_T max, + mongocrypt_status_t *status) { BSON_ASSERT_PARAM (lowerBound); BSON_ASSERT_PARAM (upperBound); if (!includeLowerBound) { - if (*lowerBound >= max) { - CLIENT_ERR ("Lower bound (%" FMT_UINT_T - ") must be less than the range maximum (%" FMT_UINT_T + if (UINT_COMPARE (*lowerBound, max) >= 0) { + CLIENT_ERR ("Lower bound (%" UINT_FMT_S + ") must be less than the range maximum (%" UINT_FMT_S ") if lower bound is excluded from range.", - *lowerBound, - max); + UINT_FMT_ARG (*lowerBound), + UINT_FMT_ARG (max)); return false; } - *lowerBound += 1u; + *lowerBound = UINT_ADD (*lowerBound, UINT_C (1)); } if (!includeUpperBound) { - if (*upperBound <= min) { - CLIENT_ERR ("Upper bound (%" FMT_UINT_T - ") must be greater than the range minimum (%" FMT_UINT_T + if (UINT_COMPARE (*upperBound, min) <= 0) { + CLIENT_ERR ("Upper bound (%" UINT_FMT_S + ") must be greater than the range minimum (%" UINT_FMT_S ") if upper bound is excluded from range.", - *upperBound, - max); + UINT_FMT_ARG (*upperBound), + UINT_FMT_ARG (min)); return false; } - *upperBound -= 1u; + *upperBound = UINT_SUB (*upperBound, UINT_C (1)); } return true; } #undef UINT_T #undef UINT_C -#undef FMT_UINT_T -#undef WITH_BITS +#undef UINT_FMT_S +#undef UINT_FMT_ARG +#undef DECORATE_NAME +#undef BITS +#undef UINT_COMPARE +#undef UINT_ADD +#undef UINT_SUB +#undef UINT_LSHIFT +#undef UINT_BITOR +#undef MC_UINT_MAX +#undef ZERO +#undef UINT_LESSTHAN diff --git a/src/mc-range-mincover-private.h b/src/mc-range-mincover-private.h index 78d6bafdf..1a9ec6daf 100644 --- a/src/mc-range-mincover-private.h +++ b/src/mc-range-mincover-private.h @@ -21,6 +21,7 @@ #include #include "mc-optional-private.h" #include "mongocrypt-status-private.h" +#include "mc-dec128.h" // mc_mincover_t represents the results of the mincover algorithm. typedef struct _mc_mincover_t mc_mincover_t; @@ -88,4 +89,22 @@ mc_getMincoverDouble (mc_getMincoverDouble_args_t args, mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT; + +typedef struct { + mc_dec128 lowerBound; + bool includeLowerBound; + mc_dec128 upperBound; + bool includeUpperBound; + size_t sparsity; + mc_optional_dec128_t min, max; + mc_optional_uint32_t precision; +} mc_getMincoverDecimal128_args_t; + +// mc_getMincoverDecimal128 implements the Mincover Generation algorithm +// described in SERVER-68600 for Decimal128 (as mc_dec128). +mc_mincover_t * +mc_getMincoverDecimal128 (mc_getMincoverDecimal128_args_t args, + mongocrypt_status_t *status) + MONGOCRYPT_WARN_UNUSED_RESULT; + #endif /* MC_RANGE_MINCOVER_PRIVATE_H */ diff --git a/src/mc-range-mincover.c b/src/mc-range-mincover.c index a8e1de445..d5c9dd172 100644 --- a/src/mc-range-mincover.c +++ b/src/mc-range-mincover.c @@ -68,49 +68,73 @@ mc_mincover_destroy (mc_mincover_t *mincover) bson_free (mincover); } -#define BITS 32 +#define UINT_T uint32_t +#define UINT_C UINT32_C +#define UINT_FMT_S PRIu32 +#define DECORATE_NAME(N) N##_u32 #include "mc-range-mincover-generator.template.h" -#undef BITS + +#define UINT_T uint64_t +#define UINT_C UINT64_C +#define UINT_FMT_S PRIu64 +#define DECORATE_NAME(N) N##_u64 +#include "mc-range-mincover-generator.template.h" + +#define UINT_T mlib_int128 +#define UINT_C MLIB_INT128 +#define UINT_FMT_S "s" +#define UINT_FMT_ARG(X) (mlib_int128_format (X).str) +#define DECORATE_NAME(N) N##_u128 +#define UINT_LESSTHAN(L, R) (mlib_int128_ucmp (L, R) < 0) +#define UINT_ADD mlib_int128_add +#define UINT_SUB mlib_int128_sub +#define UINT_LSHIFT mlib_int128_lshift +#define MC_UINT_MAX MLIB_INT128_UMAX +#define UINT_BITOR mlib_int128_bitor +#include "mc-range-mincover-generator.template.h" + // Check bounds and return an error message including the original inputs. -#define CHECK_BOUNDS(args, FMT) \ +#define IDENTITY(X) X +#define LESSTHAN(L, R) ((L) < (R)) +#define CHECK_BOUNDS(args, FMT, FormatArg, LessThan) \ if (1) { \ if ((args).min.set) { \ - if ((args).upperBound < (args).min.value) { \ + if (LessThan ((args).upperBound, (args).min.value)) { \ CLIENT_ERR ( \ "Upper bound (%" FMT \ ") must be greater than or equal to the range minimum (%" FMT \ ")", \ - (args).upperBound, \ - (args).min.value); \ + FormatArg ((args).upperBound), \ + FormatArg ((args).min.value)); \ return false; \ } \ if (!(args).includeUpperBound && \ - (args).upperBound <= (args).min.value) { \ + !LessThan ((args.min.value), (args.upperBound))) { \ CLIENT_ERR ("Upper bound (%" FMT \ ") must be greater than the range minimum (%" FMT \ ") if upper bound is excluded from range", \ - (args).upperBound, \ - (args).min.value); \ + FormatArg ((args).upperBound), \ + FormatArg ((args).min.value)); \ return false; \ } \ } \ if ((args).max.set) { \ - if ((args).lowerBound > (args).max.value) { \ + if (LessThan ((args).max.value, (args).lowerBound)) { \ CLIENT_ERR ( \ "Lower bound (%" FMT \ ") must be less than or equal to the range maximum (%" FMT ")", \ - (args).lowerBound, \ - (args).max.value); \ + FormatArg ((args).lowerBound), \ + FormatArg ((args).max.value)); \ return false; \ } \ if (!(args).includeLowerBound && \ - (args).lowerBound >= (args).max.value) { \ + !LessThan ((args).lowerBound, (args).max.value)) { \ CLIENT_ERR ("Lower bound (%" FMT \ ") must be less than the range maximum (%" FMT \ ") if lower bound is excluded from range", \ - (args).lowerBound, \ - (args).max.value); \ + FormatArg ((args).lowerBound), \ + FormatArg ((args).max.value)); \ return false; \ } \ } \ @@ -122,7 +146,7 @@ mc_getMincoverInt32 (mc_getMincoverInt32_args_t args, mongocrypt_status_t *status) { BSON_ASSERT_PARAM (status); - CHECK_BOUNDS (args, PRId32); + CHECK_BOUNDS (args, PRId32, IDENTITY, LESSTHAN); mc_OSTType_Int32 a, b; if (!mc_getTypeInfo32 ((mc_getTypeInfo32_args_t){.min = args.min, .max = args.max, @@ -162,16 +186,12 @@ mc_getMincoverInt32 (mc_getMincoverInt32_args_t args, return mc; } -#define BITS 64 -#include "mc-range-mincover-generator.template.h" -#undef BITS - mc_mincover_t * mc_getMincoverInt64 (mc_getMincoverInt64_args_t args, mongocrypt_status_t *status) { BSON_ASSERT_PARAM (status); - CHECK_BOUNDS (args, PRId64); + CHECK_BOUNDS (args, PRId64, IDENTITY, LESSTHAN); mc_OSTType_Int64 a, b; if (!mc_getTypeInfo64 ((mc_getTypeInfo64_args_t){.min = args.min, .max = args.max, @@ -218,7 +238,7 @@ mc_getMincoverDouble (mc_getMincoverDouble_args_t args, mongocrypt_status_t *status) { BSON_ASSERT_PARAM (status); - CHECK_BOUNDS (args, "g"); + CHECK_BOUNDS (args, "g", IDENTITY, LESSTHAN); mc_OSTType_Double a, b; if (!mc_getTypeInfoDouble ( @@ -262,3 +282,54 @@ mc_getMincoverDouble (mc_getMincoverDouble_args_t args, MinCoverGenerator_destroy_u64 (mcg); return mc; } + +mc_mincover_t * +mc_getMincoverDecimal128 (mc_getMincoverDecimal128_args_t args, + mongocrypt_status_t *status) +{ + BSON_ASSERT_PARAM (status); +#define ToString(Dec) (mc_dec128_to_string (Dec).str) + CHECK_BOUNDS (args, "s", ToString, mc_dec128_less); + + mc_OSTType_Decimal128 a, b; + if (!mc_getTypeInfoDecimal128 ( + (mc_getTypeInfoDecimal128_args_t){.value = args.lowerBound, + .min = args.min, + .max = args.max, + .precision = args.precision}, + &a, + status)) { + return NULL; + } + if (!mc_getTypeInfoDecimal128 ( + (mc_getTypeInfoDecimal128_args_t){.value = args.upperBound, + .min = args.min, + .max = args.max, + .precision = args.precision}, + &b, + status)) { + return NULL; + } + + BSON_ASSERT (mlib_int128_eq (a.min, b.min)); + BSON_ASSERT (mlib_int128_eq (a.max, b.max)); + + if (!adjustBounds_u128 (&a.value, + args.includeLowerBound, + a.min, + &b.value, + args.includeUpperBound, + b.max, + status)) { + return NULL; + } + + MinCoverGenerator_u128 *mcg = MinCoverGenerator_new_u128 ( + a.value, b.value, a.max, args.sparsity, status); + if (!mcg) { + return NULL; + } + mc_mincover_t *mc = MinCoverGenerator_minCover_u128 (mcg); + MinCoverGenerator_destroy_u128 (mcg); + return mc; +} diff --git a/src/mc-rangeopts.c b/src/mc-rangeopts.c index 3bacc1579..3b6a8d85a 100644 --- a/src/mc-rangeopts.c +++ b/src/mc-rangeopts.c @@ -282,6 +282,13 @@ mc_RangeOpts_appendMin (const mc_RangeOpts_t *ro, CLIENT_ERR ("failed to append BSON"); return false; } + } else if (valueType == BSON_TYPE_DECIMAL128) { + const bson_decimal128_t min = + mc_dec128_to_bson_decimal128 (MC_DEC128_LARGEST_NEGATIVE); + if (!BSON_APPEND_DECIMAL128 (out, fieldName, &min)) { + CLIENT_ERR ("failed to append BSON"); + return false; + } } else { CLIENT_ERR ("unsupported BSON type: %s for range", mc_bson_type_to_string (valueType)); @@ -337,6 +344,13 @@ mc_RangeOpts_appendMax (const mc_RangeOpts_t *ro, CLIENT_ERR ("failed to append BSON"); return false; } + } else if (valueType == BSON_TYPE_DECIMAL128) { + const bson_decimal128_t max = + mc_dec128_to_bson_decimal128 (MC_DEC128_LARGEST_POSITIVE); + if (!BSON_APPEND_DECIMAL128 (out, fieldName, &max)) { + CLIENT_ERR ("failed to append BSON"); + return false; + } } else { CLIENT_ERR ("unsupported BSON type: %s for range", mc_bson_type_to_string (valueType)); diff --git a/src/mc-reader.c b/src/mc-reader.c index 8b87b815f..a5730bd74 100644 --- a/src/mc-reader.c +++ b/src/mc-reader.c @@ -185,7 +185,8 @@ mc_reader_read_buffer (mc_reader_t *reader, buf, ptr, (size_t) length)) { CLIENT_ERR ("%s failed to copy " "data of length %" PRIu64, - reader->parser_name); + reader->parser_name, + length); return false; } diff --git a/src/mlib/check.hpp b/src/mlib/check.hpp new file mode 100644 index 000000000..18642b2f6 --- /dev/null +++ b/src/mlib/check.hpp @@ -0,0 +1,89 @@ +#ifndef MLIB_CHECK_HPP_INCLUDED +#define MLIB_CHECK_HPP_INCLUDED + +#include +#include +#include + +namespace mlib +{ +namespace detail +{ +struct check_info { + const char *filename; + int line; + const char *expr; +}; + +struct nil { +}; + +template struct bound_lhs { + check_info info; + Left value; + +#define DEFOP(Oper) \ + template nil operator Oper (Rhs rhs) const noexcept \ + { \ + if (value Oper rhs) { \ + return {}; \ + } \ + std::fprintf (stderr, \ + "%s:%d: CHECK( %s ) failed!\n", \ + info.filename, \ + info.line, \ + info.expr); \ + std::cerr << "Expanded expression: " << value << " " #Oper " " << rhs \ + << '\n'; \ + std::exit (2); \ + } + DEFOP (==) + DEFOP (!=) + DEFOP (<) + DEFOP (<=) + DEFOP (>) + DEFOP (>=) +#undef DEFOP +}; + +struct check_magic { + check_info info; + + template + bound_lhs + operator->*(Oper op) + { + return bound_lhs{info, op}; + } +}; + +struct check_consume { + void + operator= (nil) + { + } + + void + operator= (bound_lhs const &l) + { + // Invoke the test for truthiness: + (void) (l == true); + } +}; + +/** + * @brief Create an assertion that prints the expanded expression upon failure. + * + * Only supports simple comparison binary expressions, and plain boolean + * expressions + */ +#define MLIB_CHECK(Cond) \ + ::mlib::detail::check_consume{} = \ + ::mlib::detail::check_magic{ \ + ::mlib::detail::check_info{__FILE__, __LINE__, #Cond}} \ + ->*Cond + +} // namespace detail +} // namespace mlib + +#endif // MLIB_CHECK_HPP_INCLUDED diff --git a/src/mlib/endian.h b/src/mlib/endian.h new file mode 100644 index 000000000..e44080dde --- /dev/null +++ b/src/mlib/endian.h @@ -0,0 +1,42 @@ +#ifndef MLIB_ENDIAN_H_INCLUDED +#define MLIB_ENDIAN_H_INCLUDED + +#ifdef __has_include +// Some platforms require including other headers that will define the necessary +// macros +#if __has_include() +// This may recursively include our own file in a pathological case, but that +// won't cause an issue. The default will include the system's version instead: +#include +#endif +#if __has_include() +#include +#endif +#endif + +#include "./macros.h" + +enum mlib_endian_kind { +#ifdef _MSC_VER // MSVC only targets little-endian arches at the moment + MLIB_ENDIAN_LITTLE = 1234, + MLIB_ENDIAN_BIG = 4321, + MLIB_ENDIAN_NATIVE = MLIB_ENDIAN_LITTLE, +#elif defined(__BYTE_ORDER__) // Commonly built-in defined in newer compilers + MLIB_ENDIAN_LITTLE = __ORDER_LITTLE_ENDIAN__, + MLIB_ENDIAN_BIG = __ORDER_BIG_ENDIAN__, + MLIB_ENDIAN_NATIVE = __BYTE_ORDER__, +#elif defined(__BYTE_ORDER) // Common in or + MLIB_ENDIAN_LITTLE = __LITTLE_ENDIAN, + MLIB_ENDIAN_BIG = __BIG_ENDIAN, + MLIB_ENDIAN_NATIVE = __BYTE_ORDER, +#else +#error This compiler does not define an endianness macro. +#endif +}; + +enum { + MLIB_IS_LITTLE_ENDIAN = MLIB_ENDIAN_NATIVE == MLIB_ENDIAN_LITTLE, + MLIB_IS_BIG_ENDIAN = MLIB_ENDIAN_NATIVE == MLIB_ENDIAN_BIG, +}; + +#endif // MLIB_ENDIAN_H_INCLUDED diff --git a/src/mlib/int128.h b/src/mlib/int128.h index dfb02a026..149411710 100644 --- a/src/mlib/int128.h +++ b/src/mlib/int128.h @@ -131,7 +131,7 @@ mlib_int128_add (mlib_int128 left, mlib_int128 right) { uint64_t losum = left.r.lo + right.r.lo; // Overflow check - int carry = (losum < left.r.lo || losum < right.r.lo); + unsigned carry = (losum < left.r.lo || losum < right.r.lo); uint64_t hisum = left.r.hi + right.r.hi + carry; return MLIB_INIT (mlib_int128) MLIB_INT128_FROM_PARTS (losum, hisum); } @@ -156,7 +156,7 @@ mlib_int128_negate (mlib_int128 v) static mlib_constexpr_fn mlib_int128 mlib_int128_sub (mlib_int128 from, mlib_int128 less) { - int borrow = from.r.lo < less.r.lo; + unsigned borrow = from.r.lo < less.r.lo; uint64_t low = from.r.lo - less.r.lo; uint64_t high = from.r.hi - less.r.hi; high -= borrow; @@ -338,7 +338,7 @@ _mlibKnuth431D (uint32_t *const u, u[i + j] = (u32) (t); k = t >> 32; } - u[j + n] += (int32_t) k; + u[j + n] += (u32) k; } // D7: @@ -516,9 +516,9 @@ mlib_int128_divmod (mlib_int128 numer, mlib_int128 denom) (uint32_t) (denom.r.hi >> (32 - d)), }; if (d != 0) { - u[2] |= numer.r.lo >> (64 - d); - u[4] |= numer.r.hi >> (64 - d); - v[2] |= denom.r.lo >> (64 - d); + u[2] |= (uint32_t) (numer.r.lo >> (64 - d)); + u[4] |= (uint32_t) (numer.r.hi >> (64 - d)); + v[2] |= (uint32_t) (denom.r.lo >> (64 - d)); }; uint32_t q[2] = {0}; @@ -561,7 +561,7 @@ mlib_int128_mod (mlib_int128 numer, mlib_int128 denom) * @brief Get the nth power of ten as a 128-bit number */ static mlib_constexpr_fn mlib_int128 -mlib_int128_pow10 (long nth) +mlib_int128_pow10 (uint8_t nth) { mlib_int128 r = MLIB_INT128 (1); while (nth-- > 0) { @@ -574,9 +574,9 @@ mlib_int128_pow10 (long nth) * @brief Get the Nth power of two as a 128-bit number */ static mlib_constexpr_fn mlib_int128 -mlib_int128_pow2 (long nth) +mlib_int128_pow2 (uint8_t nth) { - return mlib_int128_lshift (MLIB_INT128 (1), nth); + return mlib_int128_lshift (MLIB_INT128 (1), (int) nth); } /** @@ -612,7 +612,8 @@ mlib_int128_from_string (const char *s, const char **end) continue; } if (c >= 'a') { - c -= 'a' - 'A'; // Uppercase (if a letter, otherwise some other punct) + // Uppercase (if a letter, otherwise some other punct): + c = (char) (c - ('a' - 'A')); } int digit = c - '0'; if (c >= 'A') { @@ -655,7 +656,7 @@ typedef struct { static mlib_constexpr_fn mlib_int128_charbuf mlib_int128_format (mlib_int128 i) { - mlib_int128_charbuf into = {0}; + mlib_int128_charbuf into = {{0}}; char *out = into.str + (sizeof into) - 1; int len = 0; if (mlib_int128_eq (i, MLIB_INT128 (0))) { diff --git a/src/mlib/int128.test.cpp b/src/mlib/int128.test.cpp index e9e247888..d93466381 100644 --- a/src/mlib/int128.test.cpp +++ b/src/mlib/int128.test.cpp @@ -1,5 +1,8 @@ #include "./int128.h" +#include "./check.hpp" +#define CHECK MLIB_CHECK + #include #include #include @@ -155,73 +158,6 @@ operator<< (std::ostream &out, const mlib_int128 &v) return out; } -struct check_info { - const char *filename; - int line; - const char *expr; -}; - -struct nil { -}; - -template struct bound_lhs { - check_info info; - Left value; - -#define DEFOP(Oper) \ - template nil operator Oper (Rhs rhs) const noexcept \ - { \ - if (value Oper rhs) { \ - return {}; \ - } \ - fprintf (stderr, \ - "%s:%d: CHECK( %s ) failed!\n", \ - info.filename, \ - info.line, \ - info.expr); \ - fprintf (stderr, "Expanded expression: "); \ - std::cerr << value << " " #Oper " " << rhs << '\n'; \ - std::exit (1); \ - return {}; \ - } - DEFOP (==) - DEFOP (!=) - DEFOP (<) - DEFOP (<=) - DEFOP (>) - DEFOP (>=) -#undef DEFOP -}; - -struct check_magic { - check_info info; - - template - bound_lhs - operator->*(Oper op) - { - return bound_lhs{info, op}; - } -}; - -struct check_consume { - void - operator= (nil) - { - } - - void - operator= (bound_lhs const &l) - { - // Invoke the test for truthiness: - (void) (l == true); - } -}; - -#undef CHECK -#define CHECK(Cond) \ - check_consume{} = check_magic{check_info{__FILE__, __LINE__, #Cond}}->*Cond - #ifndef BROKEN_CONSTEXPR static_assert (mlib_int128 (MLIB_INT128_UMAX) == 340282366920938463463374607431768211455_i128, diff --git a/src/mlib/macros.h b/src/mlib/macros.h index f586597b4..143116225 100644 --- a/src/mlib/macros.h +++ b/src/mlib/macros.h @@ -43,4 +43,11 @@ */ #define mlib_constexpr_fn _mlibConstexprFn +#ifdef __GNUC__ +#define MLIB_ANNOTATE_PRINTF(FStringArgAt, VarArgsStartAt) \ + __attribute__ ((format (__printf__, FStringArgAt, VarArgsStartAt))) +#else +#define MLIB_ANNOTATE_PRINTF(FStringArgAt, VarArgsStartAt) /* no-op */ +#endif + #endif // MLIB_MACROS_H_INCLUDED diff --git a/src/mlib/str.h b/src/mlib/str.h index 3c36b61fe..18f9ee9d3 100644 --- a/src/mlib/str.h +++ b/src/mlib/str.h @@ -975,6 +975,54 @@ mlib_strlen (const char *s) return r; } +/** + * @brief Copy characters into the destination, guaranteed null-terminated and + * bounds checked. + * + * @param dst Pointer to the beginning of the destination array. + * @param dst_bufsize The size of the destination array, in characters. MUST be + * greater than zero. + * @param src Pointer to the beginning of a null-terminated character array. + * @param src_bufsize The size of the array pointed-to by `src`. + * @return size_t The number `R` of characters written (NOT including the null + * terminator). R is guaranteed to be less than dst_bufsize, and + * less-than-or-equal-to src_bufsize. + * + * @note Characters beyond (dst + R) are unmodified. dst[R] is guaranteed to + * be a null terminator. + */ +static mlib_constexpr_fn size_t +mlib_strnmcopy (char *dst, + size_t dst_bufsize, + const char *src, + size_t src_bufsize) +{ + // No empty destination, since we *must* write a null terminator: + assert (dst_bufsize > 0); + // The maximum number of characters in the dest is one less than the buffer + // size, since we need room for the null terminator: + const size_t dstlen = dst_bufsize - 1u; + // The actual maximum number of characters we can copy is the less of the + // source length and the dest length: + const size_t minlen = dstlen < src_bufsize ? dstlen : src_bufsize; + // Track what we copy: + size_t ncopied = 0; + while (ncopied != minlen // Stop if we hit our character limit + && *src != 0 // Or if we hit the null terminator in the source + ) { + // Copy: + *dst = *src; + // Advance: + ++dst; + ++src; + ++ncopied; + } + // "dst" now points past the final character we copied (if any), and is still + // in-bounds. This will be the null terminator. + *dst = 0; + return ncopied; +} + MLIB_C_LINKAGE_END #endif // MONGOCRYPT_STR_PRIVATE_H diff --git a/src/mongocrypt-key-broker.c b/src/mongocrypt-key-broker.c index 83433aeb5..fbb6b20ac 100644 --- a/src/mongocrypt-key-broker.c +++ b/src/mongocrypt-key-broker.c @@ -151,7 +151,7 @@ _key_broker_fail_w_msg (_mongocrypt_key_broker_t *kb, const char *msg) kb->state = KB_ERROR; status = kb->status; - CLIENT_ERR (msg); + CLIENT_ERR ("%s", msg); return false; } diff --git a/src/mongocrypt-marking.c b/src/mongocrypt-marking.c index 3062d046d..a01c97414 100644 --- a/src/mongocrypt-marking.c +++ b/src/mongocrypt-marking.c @@ -701,6 +701,22 @@ get_edges (mc_FLE2RangeInsertSpec_t *insertSpec, return mc_getEdgesDouble (args, status); } + else if (value_type == BSON_TYPE_DECIMAL128) { + const mc_dec128 value = mc_dec128_from_bson_iter (&insertSpec->v); + mc_getEdgesDecimal128_args_t args = { + .value = value, + .sparsity = sparsity, + }; + if (insertSpec->precision.set) { + const mc_dec128 min = mc_dec128_from_bson_iter (&insertSpec->min); + const mc_dec128 max = mc_dec128_from_bson_iter (&insertSpec->max); + args.min = OPT_MC_DEC128 (min); + args.max = OPT_MC_DEC128 (max); + args.precision = insertSpec->precision; + } + return mc_getEdgesDecimal128 (args, status); + } + CLIENT_ERR ("unsupported BSON type: %s for range", mc_bson_type_to_string (value_type)); @@ -1160,10 +1176,30 @@ mc_get_mincover_from_FLE2RangeFindSpec (mc_FLE2RangeFindSpec_t *findSpec, } return mc_getMincoverDouble (args, status); } - case BSON_TYPE_DECIMAL128: - CLIENT_ERR ("FLE2 find not yet implemented for type: %s", - mc_bson_type_to_string (bsonType)); - return NULL; + case BSON_TYPE_DECIMAL128: { + BSON_ASSERT (bson_iter_type (&lowerBound) == BSON_TYPE_DECIMAL128); + BSON_ASSERT (bson_iter_type (&upperBound) == BSON_TYPE_DECIMAL128); + BSON_ASSERT (bson_iter_type (&findSpec->edgesInfo.value.indexMin) == + BSON_TYPE_DECIMAL128); + BSON_ASSERT (bson_iter_type (&findSpec->edgesInfo.value.indexMax) == + BSON_TYPE_DECIMAL128); + + mc_getMincoverDecimal128_args_t args = { + .lowerBound = mc_dec128_from_bson_iter (&lowerBound), + .includeLowerBound = includeLowerBound, + .upperBound = mc_dec128_from_bson_iter (&upperBound), + .includeUpperBound = includeUpperBound, + .sparsity = sparsity, + }; + if (findSpec->edgesInfo.value.precision.set) { + args.min = OPT_MC_DEC128 ( + mc_dec128_from_bson_iter (&findSpec->edgesInfo.value.indexMin)); + args.max = OPT_MC_DEC128 ( + mc_dec128_from_bson_iter (&findSpec->edgesInfo.value.indexMax)); + args.precision = findSpec->edgesInfo.value.precision; + } + return mc_getMincoverDecimal128 (args, status); + } case BSON_TYPE_EOD: case BSON_TYPE_UTF8: diff --git a/src/mongocrypt-private.h b/src/mongocrypt-private.h index 2e8a24320..e4ff1e15e 100644 --- a/src/mongocrypt-private.h +++ b/src/mongocrypt-private.h @@ -33,6 +33,8 @@ #include "mongo_crypt-v1.h" +#include + #define MONGOCRYPT_GENERIC_ERROR_CODE 1 @@ -65,6 +67,7 @@ const char * tmp_buf (const _mongocrypt_buffer_t *buf); +MLIB_ANNOTATE_PRINTF (4, 5) void _mongocrypt_set_error (mongocrypt_status_t *status, mongocrypt_status_type_t type, diff --git a/src/mongocrypt.c b/src/mongocrypt.c index 5e2dbaad2..5b4f78888 100644 --- a/src/mongocrypt.c +++ b/src/mongocrypt.c @@ -310,7 +310,7 @@ mongocrypt_setopt_schema_map (mongocrypt_t *crypt, } if (!bson_validate_with_error (&tmp, BSON_VALIDATE_NONE, &bson_err)) { - CLIENT_ERR (bson_err.message); + CLIENT_ERR ("%s", bson_err.message); return false; } @@ -353,7 +353,7 @@ mongocrypt_setopt_encrypted_field_config_map (mongocrypt_t *crypt, } if (!bson_validate_with_error (&as_bson, BSON_VALIDATE_NONE, &bson_err)) { - CLIENT_ERR (bson_err.message); + CLIENT_ERR ("%s", bson_err.message); return false; } diff --git a/test/data/fle2-find-range/decimal128-precision/cmd.json b/test/data/fle2-find-range/decimal128-precision/cmd.json new file mode 100644 index 000000000..134d41b71 --- /dev/null +++ b/test/data/fle2-find-range/decimal128-precision/cmd.json @@ -0,0 +1,6 @@ +{ + "find": "test", + "filter": { + "encrypted": {"$numberDecimal":"4.56000000000000"} + } +} diff --git a/test/data/fle2-find-range/decimal128-precision/encrypted-field-map.json b/test/data/fle2-find-range/decimal128-precision/encrypted-field-map.json new file mode 100644 index 000000000..63658fbca --- /dev/null +++ b/test/data/fle2-find-range/decimal128-precision/encrypted-field-map.json @@ -0,0 +1,31 @@ +{ + "db.test": { + "escCollection": "fle2.test.esc", + "eccCollection": "fle2.test.ecc", + "ecocCollection": "fle2.test.ecoc", + "fields": [ + { + "keyId": { + "$binary": { + "base64": "EjRWeBI0mHYSNBI0VniQEg==", + "subType": "04" + } + }, + "path": "encrypted", + "bsonType": "decimal", + "queries": { + "queryType": "rangePreview", + "contention": { + "$numberInt": "0" + }, + "sparsity": { + "$numberInt": "1" + }, + "min": {"$numberDecimal":"0"}, + "max":{"$numberDecimal":"1234567890123456789"}, + "precision":{"$numberInt":"2"} + } + } + ] + } +} diff --git a/test/data/fle2-find-range/decimal128-precision/encrypted-payload.json b/test/data/fle2-find-range/decimal128-precision/encrypted-payload.json new file mode 100644 index 000000000..b5959d790 --- /dev/null +++ b/test/data/fle2-find-range/decimal128-precision/encrypted-payload.json @@ -0,0 +1,51 @@ +{ + "find": "test", + "filter": { + "encrypted": { + "$binary": { + "base64": "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", + "subType": "6" + } + } + }, + "encryptionInformation": { + "type": 1, + "schema": { + "db.test": { + "escCollection": "fle2.test.esc", + "eccCollection": "fle2.test.ecc", + "ecocCollection": "fle2.test.ecoc", + "fields": [ + { + "keyId": { + "$binary": { + "base64": "EjRWeBI0mHYSNBI0VniQEg==", + "subType": "04" + } + }, + "path": "encrypted", + "bsonType": "decimal", + "queries": { + "queryType": "rangePreview", + "contention": { + "$numberInt": "0" + }, + "sparsity": { + "$numberInt": "1" + }, + "min": { + "$numberDecimal": "0" + }, + "max": { + "$numberDecimal": "1234567890123456789" + }, + "precision": { + "$numberInt": "2" + } + } + } + ] + } + } + } +} \ No newline at end of file diff --git a/test/data/fle2-find-range/decimal128-precision/mongocryptd-reply.json b/test/data/fle2-find-range/decimal128-precision/mongocryptd-reply.json new file mode 100644 index 000000000..82381f7d3 --- /dev/null +++ b/test/data/fle2-find-range/decimal128-precision/mongocryptd-reply.json @@ -0,0 +1,59 @@ +{ + "ok": { + "$numberInt": "1" + }, + "result": { + "find": "test", + "filter": { + "encrypted": { + "$binary": { + "base64": "AysBAAAQdAACAAAAEGEAAwAAAAVraQAQAAAABBI0VngSNJh2EjQSNFZ4kBIFa3UAEAAAAASrze+rEjSYdhI0EjRWeJASA3YAzAAAAANlZGdlc0luZm8AmgAAABNsb3dlckJvdW5kAAAAAAAAAAAAAAAAAAAAQDAIbGJJbmNsdWRlZAABE3VwcGVyQm91bmQAFYHpffQQIhEAAAAAAABAMAh1YkluY2x1ZGVkAAEQcHJlY2lzaW9uAAIAAAATaW5kZXhNaW4AAAAAAAAAAAAAAAAAAABAMBNpbmRleE1heAAVgel99BAiEQAAAAAAAEAwABBwYXlsb2FkSWQA0gQAABBmaXJzdE9wZXJhdG9yAAEAAAAAEmNtAAAAAAAAAAAAEnMAAQAAAAAAAAAA", + "subType": "6" + } + } + }, + "encryptionInformation": { + "type": { + "$numberInt": "1" + }, + "schema": { + "db.test": { + "escCollection": "fle2.test.esc", + "eccCollection": "fle2.test.ecc", + "ecocCollection": "fle2.test.ecoc", + "fields": [ + { + "keyId": { + "$binary": { + "base64": "EjRWeBI0mHYSNBI0VniQEg==", + "subType": "04" + } + }, + "path": "encrypted", + "bsonType": "decimal", + "queries": { + "queryType": "rangePreview", + "contention": { + "$numberInt": "0" + }, + "sparsity": { + "$numberInt": "1" + }, + "min": { + "$numberDecimal": "0" + }, + "max": { + "$numberDecimal": "1234567890123456789" + }, + "precision": { + "$numberInt": "2" + } + } + } + ] + } + } + } + }, + "hasEncryptedPlaceholders": true +} \ No newline at end of file diff --git a/test/data/fle2-find-range/decimal128/cmd.json b/test/data/fle2-find-range/decimal128/cmd.json new file mode 100644 index 000000000..7f32eb979 --- /dev/null +++ b/test/data/fle2-find-range/decimal128/cmd.json @@ -0,0 +1,6 @@ +{ + "find": "test", + "filter": { + "encrypted": {"$numberDecimal":"1.23000000000000"} + } +} diff --git a/test/data/fle2-find-range/decimal128/encrypted-field-map.json b/test/data/fle2-find-range/decimal128/encrypted-field-map.json new file mode 100644 index 000000000..a2068cd27 --- /dev/null +++ b/test/data/fle2-find-range/decimal128/encrypted-field-map.json @@ -0,0 +1,28 @@ +{ + "db.test": { + "escCollection": "fle2.test.esc", + "eccCollection": "fle2.test.ecc", + "ecocCollection": "fle2.test.ecoc", + "fields": [ + { + "keyId": { + "$binary": { + "base64": "EjRWeBI0mHYSNBI0VniQEg==", + "subType": "04" + } + }, + "path": "encrypted", + "bsonType": "decimal", + "queries": { + "queryType": "rangePreview", + "contention": { + "$numberInt": "0" + }, + "sparsity": { + "$numberInt": "1" + } + } + } + ] + } +} diff --git a/test/data/fle2-find-range/decimal128/encrypted-payload.json b/test/data/fle2-find-range/decimal128/encrypted-payload.json new file mode 100644 index 000000000..b96692436 --- /dev/null +++ b/test/data/fle2-find-range/decimal128/encrypted-payload.json @@ -0,0 +1,42 @@ +{ + "find": "test", + "filter": { + "encrypted": { + "$binary": { + "base64": "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", + "subType": "6" + } + } + }, + "encryptionInformation": { + "type": 1, + "schema": { + "db.test": { + "escCollection": "fle2.test.esc", + "eccCollection": "fle2.test.ecc", + "ecocCollection": "fle2.test.ecoc", + "fields": [ + { + "keyId": { + "$binary": { + "base64": "EjRWeBI0mHYSNBI0VniQEg==", + "subType": "04" + } + }, + "path": "encrypted", + "bsonType": "decimal", + "queries": { + "queryType": "rangePreview", + "contention": { + "$numberInt": "0" + }, + "sparsity": { + "$numberInt": "1" + } + } + } + ] + } + } + } +} \ No newline at end of file diff --git a/test/data/fle2-find-range/decimal128/mongocryptd-reply.json b/test/data/fle2-find-range/decimal128/mongocryptd-reply.json new file mode 100644 index 000000000..1e47ad99e --- /dev/null +++ b/test/data/fle2-find-range/decimal128/mongocryptd-reply.json @@ -0,0 +1,50 @@ +{ + "ok": { + "$numberInt": "1" + }, + "result": { + "find": "test", + "filter": { + "encrypted": { + "$binary": { + "base64": "AxwBAAAQdAACAAAAEGEAAwAAAAVraQAQAAAABBI0VngSNJh2EjQSNFZ4kBIFa3UAEAAAAASrze+rEjSYdhI0EjRWeJASA3YAvQAAAANlZGdlc0luZm8AiwAAABNsb3dlckJvdW5kAAAAAAAAAAAAAAAAAAAAQDAIbGJJbmNsdWRlZAABE3VwcGVyQm91bmQAFYHpffQQIhEAAAAAAABAMAh1YkluY2x1ZGVkAAETaW5kZXhNaW4A/////2OOjTfAh62+Ce3/3xNpbmRleE1heAD/////Y46NN8CHrb4J7f9fABBwYXlsb2FkSWQA0gQAABBmaXJzdE9wZXJhdG9yAAEAAAAAEmNtAAAAAAAAAAAAEnMAAQAAAAAAAAAA", + "subType": "6" + } + } + }, + "encryptionInformation": { + "type": { + "$numberInt": "1" + }, + "schema": { + "db.test": { + "escCollection": "fle2.test.esc", + "eccCollection": "fle2.test.ecc", + "ecocCollection": "fle2.test.ecoc", + "fields": [ + { + "keyId": { + "$binary": { + "base64": "EjRWeBI0mHYSNBI0VniQEg==", + "subType": "04" + } + }, + "path": "encrypted", + "bsonType": "decimal", + "queries": { + "queryType": "rangePreview", + "contention": { + "$numberInt": "0" + }, + "sparsity": { + "$numberInt": "1" + } + } + } + ] + } + } + } + }, + "hasEncryptedPlaceholders": true +} \ No newline at end of file diff --git a/test/data/fle2-insert-range/decimal128-precision/RNG_DATA.h b/test/data/fle2-insert-range/decimal128-precision/RNG_DATA.h new file mode 100644 index 000000000..ea7ab6508 --- /dev/null +++ b/test/data/fle2-insert-range/decimal128-precision/RNG_DATA.h @@ -0,0 +1,73 @@ +// Defines the random data for IVs to obtain a deterministic +// FLE2InsertUpdatePayload. +#define RNG_DATA \ + "\x51\xdb\xd6\x46\x8b\xcb\x43\x8d\xfe\xe7\x24\x9c\x99\x2e\x41\x39" \ + "\x18\x13\xcf\x9b\xa9\x94\xb8\x3b\x81\xc1\x25\xeb\xa7\xb0\xc0\x3b" \ + "\x17\x17\xe2\x9b\x73\xec\xd9\x7f\x76\xc4\x4f\x63\x28\x3c\x05\xf2" \ + "\x9c\x7d\x48\xaf\xae\x63\x8d\x62\x60\x31\x6e\x0c\xae\x48\x9f\x45" \ + "\xd2\xc3\x8a\x5b\xe1\xd8\xd9\x23\xe4\x37\xe7\x8a\x5a\x6a\x82\x0e" \ + "\xf0\x4b\x2e\x84\xf6\x02\xae\xfd\x45\x47\xcf\x3f\xb1\x2c\xb4\xfd" \ + "\xae\xd7\x28\xea\x44\xf9\xb0\x7e\xd8\xa5\x90\xae\x51\xf6\x00\xc0" \ + "\x62\x6b\x2a\x3f\xca\x2f\x2e\xa5\x78\xfe\xfa\xe3\x11\x99\xa0\x9b" \ + "\x77\x55\x0c\xaf\x36\xc4\x8a\xd9\x72\x00\x81\x58\x34\xd4\x30\xcc" \ + "\x19\x06\x93\xf9\x51\x7a\x14\x88\x1e\x44\x9e\xb0\xf6\x49\x2b\x3b" \ + "\xf4\xfd\xdc\xf1\x49\xd4\x87\x71\x37\xef\x6f\x4c\x4e\x08\x7b\x1c" \ + "\x57\x0d\x82\x7e\xa7\x03\xbb\x83\x70\x6c\xbf\x43\x99\xf6\x63\xae" \ + "\x2f\x96\x3c\x44\xf3\x49\x22\xf7\xe6\x6d\xa6\x33\x3e\x4b\x5b\xc3" \ + "\xf5\xd2\xa9\xfc\x9c\xef\x32\x04\x76\xbf\x48\xf4\xa4\xee\x63\xb7" \ + "\x87\xdb\x48\xb0\xdd\xce\x68\xb0\x9e\x69\x60\x20\x63\xe6\x0e\x86" \ + "\x12\xbd\x3f\x9d\x5c\x58\x01\x5a\x17\xe3\xa3\x87\x18\xbe\xb2\xbf" \ + "\xcd\x8c\x12\x74\x01\x7d\xe7\xae\xd4\x2d\x91\xe7\xa8\x84\x9a\xb0" \ + "\xc9\xde\x3e\x46\x6b\x66\x93\x54\xd7\x7b\xc4\xa4\x53\x10\x73\xa1" \ + "\xec\x10\xe9\xa8\x7e\xe7\xb4\x27\x4f\xbb\xba\x5e\x67\x58\x0a\x33" \ + "\x8e\x70\x27\x8a\x12\xf1\x9b\x60\xbb\x2d\x37\x03\x68\x67\x9c\x37" \ + "\x6a\xff\xde\xf2\x6a\x01\xfd\x95\xc4\x68\xdb\x06\x62\xda\xc0\x62" \ + "\x3f\x27\xcc\xa8\x90\x66\x66\x86\xa7\x4c\x12\xf9\x92\x1e\x68\xd3" \ + "\x94\x30\xf4\x43\x85\x35\xdf\x1f\x3a\xaf\xc8\x9a\x5e\x67\x35\xa1" \ + "\xfc\xad\x9a\xc2\x9b\x39\x3b\x79\x30\x3a\x0e\x16\x6a\x11\xd9\xad" \ + "\xee\x4a\x5e\x6c\x20\x9f\x4d\x95\x3b\xe2\xa9\xaf\xd0\x43\xea\x4b" \ + "\xbd\xd9\xf5\xe3\xeb\xb6\xfe\x5a\xc4\x02\x3d\x29\x9d\x39\x85\xf2" \ + "\x4e\xac\xa8\x49\xa2\x22\x91\xa0\x9f\x1b\x4d\xd7\x21\xb6\x75\x47" \ + "\x06\xe9\x4f\x01\x5f\xd2\x99\x1d\xf1\x0c\x6f\xef\xd1\xbf\xb2\x43" \ + "\xc5\x33\x74\xb3\xc3\x8c\xfd\x80\x25\xfd\x53\xac\xc8\xf7\x91\x80" \ + "\x9e\xa0\x55\x7e\xf7\x14\x67\x7a\x74\x84\xfb\x49\xb4\x55\x99\xc8" \ + "\x28\x4a\xde\x5f\xec\x09\x56\xdd\x34\x2c\x46\x76\x3e\x82\x97\xa5" \ + "\xc9\xc1\xcb\x96\xa8\x34\xac\x93\x08\xf8\x6a\x64\xfd\x72\xc9\xee" \ + "\x3a\x71\x94\x63\x78\xc4\x5d\x28\x79\xfd\xeb\x0a\xbb\x24\x95\x2d" \ + "\xc0\xc9\xa7\xd6\x76\x35\x51\xd5\x2b\x28\x5e\xde\x4f\xb5\xff\xd2" \ + "\xbe\x12\x06\x04\xc0\xab\x5f\x76\xcb\x0f\x25\x7f\x22\x4f\xdb\xd7" \ + "\x0f\x1f\x73\x98\xcc\x24\x02\x27\xb5\x92\x80\x68\x3f\x75\x50\x59" \ + "\xbc\xe4\x2f\x2b\xcf\xbe\xce\x06\x7f\x54\x34\x45\x29\xa4\xb9\x5a" \ + "\xa7\x76\xe2\x12\xdd\x33\xdf\xdf\x7d\x5d\xcd\xad\xf9\x5f\xa7\x8e" \ + "\x76\xb2\xc2\x59\x0b\x94\xf9\xef\x11\x4a\x24\xeb\xac\xe8\x08\xad" \ + "\xb9\x92\xf8\xc3\xf0\x21\xcd\x6e\x36\xa0\x36\xdc\x9b\xb7\x19\x73" \ + "\xfe\x42\x2e\x05\x6a\xc5\x0f\x7d\x3b\x04\xdb\x5b\x33\xf2\x02\xa3" \ + "\x86\xe8\xa8\x20\x4d\x56\x23\x9b\x23\x53\x90\xb9\x80\xe9\x04\x3b" \ + "\x77\x5c\x57\x01\xc3\xd8\x40\xbb\x5d\xb5\xfa\x91\xe4\xb4\x3d\x21" \ + "\xa4\xe5\x8e\x1c\x9d\x67\x11\x3e\x51\xda\x7d\x2b\xd8\xfe\xfe\x32" \ + "\x7c\x03\x9d\x8e\x69\x07\x46\xb1\x59\x3f\xa4\xda\x40\x6f\x56\x8c" \ + "\x02\x77\xa6\x27\x0b\x71\xdf\x2b\xa6\xa4\x35\xac\x88\xc0\xd8\xa3" \ + "\x42\x2a\x00\x8d\x19\x90\x86\x27\x74\x5e\x2e\xc6\xd9\xf3\xe5\x4b" \ + "\x00\xfe\xe0\xb9\xa6\x03\xbf\x7b\x17\x25\x5c\x14\x32\x1e\xea\xec" \ + "\x20\xa6\x48\x3e\x6a\xee\x85\xb7\x3d\xad\xdd\xdd\x1c\x11\xaa\x18" \ + "\x65\xb6\xb1\x1d\x38\xe9\x19\xc3\x92\xd3\xda\xa6\x57\xd0\xf5\xbc" \ + "\x44\xf5\x58\xdf\xe9\x54\x31\xad\xc0\xcb\x17\x7a\x9b\x38\xc2\x28" \ + "\x38\x9c\x04\x05\xfa\x7f\x36\xbc\x06\x6b\x44\x16\x9a\x84\x44\xd4" \ + "\xf3\x62\x95\xd3\xa9\x49\x6e\x6e\x07\x77\x3f\xbc\x31\x34\x10\xe4" \ + "\x0f\xed\x0f\x37\x0d\xdb\x3f\xdd\x75\xb0\x63\x1b\xbc\x95\xeb\xaf" \ + "\xda\x9c\x5c\xf9\x8a\x48\x1f\xaa\xb9\x19\x64\x5e\xcb\x39\x99\x60" \ + "\xec\xaa\x29\x5f\x0b\xc5\x7a\xff\xb9\xf6\x59\x77\x87\xe6\x08\x13" \ + "\xcc\xf1\x71\xf7\xc3\x46\xfb\x7d\xa8\xc8\x17\x0f\xec\xb1\x16\x49" \ + "\xb9\x60\x06\x59\x2b\x38\x75\x25\xdc\x3a\xcf\x8c\x69\x1c\x6e\x30" \ + "\xc4\x44\x25\x94\xac\xa9\x41\xee\x9c\xed\x37\xcf\xa9\x0e\x12\x82" \ + "\x15\xd8\x48\x12\x7c\x0f\x4b\x46\xad\xf6\xb9\x9b\x29\x58\x4c\xb9" \ + "\xb4\x11\xa8\xa5\xe3\x38\xb2\x9c\x84\x37\x64\xf6\xc5\x18\x1a\x91" \ + "\x96\x1d\x7e\x36\xbc\x5a\xc4\xfd\x08\xd9\x47\x54\xa6\x43\x8b\xf0" \ + "\xf9\xd3\x0b\xef\x09\x88\xde\xca\x6d\xdd\x4f\xa0\x91\x83\xff\xb9" \ + "\xcf\xf0\xa3\x39\x6e\x29\xe4\x1e\x2d\x45\xa9\xad\x63\xb8\x9d\x41" \ + "\xf8\x92\xe4\xd4\x8c\x65\xce\x30\x10\x37\xfd\x39\x53\x73\xab\x9e" \ + "\x30\x04\x62\x06\x68\x35\xbc\x30\x47\x71\x35\x83\xaa\x41\x69\x91" \ + "\x1d\xa5\x77\xb7\xd0\xb4\xd9\x27\x58\xc6\xc7\xba\x6c\xb7\x2f\x6b" \ + "\xe9\x8a\xd4\x35\x30\x42\xa4\xef\x20\xb1\x1d\x2b\x3f\x60\xf5\xa0" \ + "\x30\x2f\xf7\x38\x6e\x17\x84\x8b\x56\x14\x12\xc7\x58\x50\xa1\x33" \ + "\xdc\xb7\x56\xa8\xc3\xa6\x26\x3f\x25\xf2\xe9\x74\xe6\xf7\x3b\xb4" diff --git a/test/data/fle2-insert-range/decimal128-precision/cmd.json b/test/data/fle2-insert-range/decimal128-precision/cmd.json new file mode 100644 index 000000000..8d334d8a2 --- /dev/null +++ b/test/data/fle2-insert-range/decimal128-precision/cmd.json @@ -0,0 +1,9 @@ +{ + "insert": "test", + "documents": [ + { + "plainText": "sample", + "encrypted": {"$numberDecimal":"4.56000000000000"} + } + ] +} diff --git a/test/data/fle2-insert-range/decimal128-precision/encrypted-field-map.json b/test/data/fle2-insert-range/decimal128-precision/encrypted-field-map.json new file mode 100644 index 000000000..63658fbca --- /dev/null +++ b/test/data/fle2-insert-range/decimal128-precision/encrypted-field-map.json @@ -0,0 +1,31 @@ +{ + "db.test": { + "escCollection": "fle2.test.esc", + "eccCollection": "fle2.test.ecc", + "ecocCollection": "fle2.test.ecoc", + "fields": [ + { + "keyId": { + "$binary": { + "base64": "EjRWeBI0mHYSNBI0VniQEg==", + "subType": "04" + } + }, + "path": "encrypted", + "bsonType": "decimal", + "queries": { + "queryType": "rangePreview", + "contention": { + "$numberInt": "0" + }, + "sparsity": { + "$numberInt": "1" + }, + "min": {"$numberDecimal":"0"}, + "max":{"$numberDecimal":"1234567890123456789"}, + "precision":{"$numberInt":"2"} + } + } + ] + } +} diff --git a/test/data/fle2-insert-range/decimal128-precision/encrypted-payload.json b/test/data/fle2-insert-range/decimal128-precision/encrypted-payload.json new file mode 100644 index 000000000..f3c5698db --- /dev/null +++ b/test/data/fle2-insert-range/decimal128-precision/encrypted-payload.json @@ -0,0 +1,54 @@ +{ + "insert": "test", + "documents": [ + { + "plainText": "sample", + "encrypted": { + "$binary": { + "base64": "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", + "subType": "6" + } + } + } + ], + "encryptionInformation": { + "type": 1, + "schema": { + "db.test": { + "escCollection": "fle2.test.esc", + "eccCollection": "fle2.test.ecc", + "ecocCollection": "fle2.test.ecoc", + "fields": [ + { + "keyId": { + "$binary": { + "base64": "EjRWeBI0mHYSNBI0VniQEg==", + "subType": "04" + } + }, + "path": "encrypted", + "bsonType": "decimal", + "queries": { + "queryType": "rangePreview", + "contention": { + "$numberInt": "0" + }, + "sparsity": { + "$numberInt": "1" + }, + "min": { + "$numberDecimal": "0" + }, + "max": { + "$numberDecimal": "1234567890123456789" + }, + "precision": { + "$numberInt": "2" + } + } + } + ] + } + } + } +} \ No newline at end of file diff --git a/test/data/fle2-insert-range/decimal128-precision/mongocryptd-reply.json b/test/data/fle2-insert-range/decimal128-precision/mongocryptd-reply.json new file mode 100644 index 000000000..4e7ee4f13 --- /dev/null +++ b/test/data/fle2-insert-range/decimal128-precision/mongocryptd-reply.json @@ -0,0 +1,62 @@ +{ + "ok": { + "$numberInt": "1" + }, + "result": { + "insert": "test", + "documents": [ + { + "plainText": "sample", + "encrypted": { + "$binary": { + "base64": "A7AAAAAQdAABAAAAEGEAAwAAAAVraQAQAAAABBI0VngSNJh2EjQSNFZ4kBIFa3UAEAAAAASrze+rEjSYdhI0EjRWeJASA3YAUQAAABN2AACABMa6ngEAAAAAAAAAJDATbWluAAAAAAAAAAAAAAAAAAAAQDATbWF4ABWB6X30ECIRAAAAAAAAQDAQcHJlY2lzaW9uAAIAAAAAEmNtAAAAAAAAAAAAEnMAAQAAAAAAAAAA", + "subType": "6" + } + } + } + ], + "encryptionInformation": { + "type": { + "$numberInt": "1" + }, + "schema": { + "db.test": { + "escCollection": "fle2.test.esc", + "eccCollection": "fle2.test.ecc", + "ecocCollection": "fle2.test.ecoc", + "fields": [ + { + "keyId": { + "$binary": { + "base64": "EjRWeBI0mHYSNBI0VniQEg==", + "subType": "04" + } + }, + "path": "encrypted", + "bsonType": "decimal", + "queries": { + "queryType": "rangePreview", + "contention": { + "$numberInt": "0" + }, + "sparsity": { + "$numberInt": "1" + }, + "min": { + "$numberDecimal": "0" + }, + "max": { + "$numberDecimal": "1234567890123456789" + }, + "precision": { + "$numberInt": "2" + } + } + } + ] + } + } + } + }, + "hasEncryptedPlaceholders": true +} \ No newline at end of file diff --git a/test/data/fle2-insert-range/decimal128/RNG_DATA.h b/test/data/fle2-insert-range/decimal128/RNG_DATA.h new file mode 100644 index 000000000..45993c923 --- /dev/null +++ b/test/data/fle2-insert-range/decimal128/RNG_DATA.h @@ -0,0 +1,134 @@ +// Defines the random data for IVs to obtain a deterministic +// FLE2InsertUpdatePayload. +#define RNG_DATA \ + "\xfc\xbf\xbe\xdc\xfe\xc2\xaf\x03\xe0\x35\x6c\xed\xb2\x78\x3d\x74" \ + "\x29\x97\xb6\x5d\xf2\x56\x70\x07\x2c\x73\x80\xce\x1e\x7b\x43\x36" \ + "\x7b\xb5\x9a\xaf\xa9\xad\xa6\x44\xfb\x66\x60\x69\x0c\x9e\x4e\x17" \ + "\x93\x3d\xdd\x2a\xdf\x76\x54\xc6\xf6\x1a\xf3\xfa\xd4\xd3\x14\xf7" \ + "\xb9\x33\xbb\xdb\x8a\x1e\x07\xc8\x5c\x0b\xa5\x4a\xe2\xfb\x27\x8d" \ + "\xaa\xf2\x36\x03\xd5\xe2\x5a\xbc\x11\x76\xb7\xb6\x86\x6b\x35\x4c" \ + "\xa9\x77\x16\xbd\x05\x15\x19\x31\x38\x8a\xba\xea\xdc\xd2\x2c\x9a" \ + "\x8b\x0c\xea\x66\xd5\x3d\x21\x01\x03\xee\x74\xd2\xf4\x8d\x8d\xf7" \ + "\x13\xf9\x35\xe4\x43\x42\xba\x2d\x8c\x00\x3a\x64\x65\xf7\x3b\x07" \ + "\x03\xda\x33\x2e\x8e\x87\x04\x97\xfd\xc7\x1f\x00\x92\x7c\x1c\x40" \ + "\xe2\xaa\x81\x47\x56\x9b\x39\x4b\x13\xc9\x71\xf2\xda\x2a\x36\x87" \ + "\x2a\x86\x87\xdc\x86\x4d\x35\x66\xf1\x4a\xc7\x8b\x9c\x88\xcd\xb3" \ + "\x94\xf8\x52\x5c\xd9\x73\xed\xbd\xd6\x96\xad\x9c\xb5\x94\xb3\xa1" \ + "\x96\x26\xe5\x59\xd3\xa3\x32\x4e\xa8\x5e\x5e\xec\x9f\x04\xb5\x9d" \ + "\x35\x0c\xc1\x2e\x69\x79\x2b\xf1\x3f\x2c\x99\x31\xf9\x42\xa3\x88" \ + "\x2c\x83\x57\x56\x41\xc9\x6a\x4d\xa5\x16\x92\x75\x99\xca\x58\xf2" \ + "\xc6\x67\x74\x7c\xb6\x2e\xe7\x71\x49\xc0\xdd\xe8\x71\xa7\x53\xbd" \ + "\xf7\x6c\x36\x0d\x9c\xa2\xfa\xee\xd7\x30\x09\x68\xd2\x47\xc6\xb6" \ + "\x54\xbc\x37\x12\x97\xab\x12\x97\xfc\x44\x0b\x82\xfb\x5d\x7c\x14" \ + "\x08\x64\x1f\x4b\x6b\x5e\x2a\x3c\x9f\xc6\xeb\x92\x79\xa8\xe6\xaf" \ + "\x0c\x32\xb2\x85\xb0\x13\x9b\xcd\x71\x31\x3d\xd8\x09\x48\x4b\x79" \ + "\x76\x22\x66\x6d\x70\xe5\x9f\xc4\x6a\xc8\x00\x6e\x59\xb4\x14\x81" \ + "\x34\xe5\xa2\xab\x4b\x72\x94\xd9\x25\x81\x85\x74\xdb\x7f\x4a\x1e" \ + "\xe7\x1b\x5e\x42\x40\x79\x56\xd2\x64\x16\xc7\x44\xb8\x3f\x3e\x53" \ + "\x6f\x9e\x19\xd4\x78\x16\xf4\xbb\x16\xca\x10\x36\x9c\x02\x69\x88" \ + "\x15\xd2\xf7\xed\x3d\x92\x8e\xca\x29\x01\xb7\xc1\x0a\x7c\x74\x86" \ + "\x69\xb3\xa4\x95\x32\xb0\xee\x2e\xb1\x79\x7c\xd8\xa1\x0c\x21\x36" \ + "\x77\x55\x76\x7b\xb4\xdf\x00\xab\x36\xae\x67\x65\x33\x99\xad\xb3" \ + "\x84\x5f\x77\x10\x43\xbc\xb2\x10\x86\xe9\x32\xc0\xb9\x7e\x59\x16" \ + "\x3d\xd9\x1c\xe3\x94\xae\xd0\x4f\x34\x81\xbb\x54\xa5\x40\x7c\xcf" \ + "\x0d\x31\xac\x64\xc1\x7a\x34\x36\xc4\xde\xee\xfd\xd9\x34\x2d\x2e" \ + "\x43\xb4\xca\x36\x7e\xc5\x13\xef\x43\x7f\x96\x42\x32\x78\x1e\x0b" \ + "\xae\xe6\x49\x0b\x6f\xdb\xb8\x52\x5b\xc0\x89\xdc\xe9\xfd\xb5\x2e" \ + "\xbb\x47\x0f\x84\x85\x44\x87\xc7\x84\xdd\x08\xd0\x08\x97\x94\x9b" \ + "\x25\x3f\x36\xab\x4e\xc0\x51\x1a\xf6\xe9\x3d\x27\x93\xe0\xf2\xb9" \ + "\x05\x03\x0d\x38\x92\x33\x3e\xa3\x0e\x46\xfe\xf7\x55\x10\x5d\xd9" \ + "\x14\x54\x8e\x6e\xba\x0c\x95\x90\x89\x00\x0f\xb2\x32\x22\x42\x0b" \ + "\x7a\x01\x9a\xdb\x6c\xf7\x98\x9f\xff\x09\x83\xce\x7f\x89\xad\xd1" \ + "\x7b\xc3\xf5\xbf\x5f\x35\x40\xb5\x89\x77\xf8\xea\x3e\x83\x03\xcd" \ + "\x31\xf8\x74\xc9\x5a\xf0\x89\xdc\x63\x08\xb7\x7a\x01\xb7\x91\x84" \ + "\xdf\x7b\x0f\x3a\xc0\x89\xff\x78\x97\x55\x3c\x33\x0f\x31\xc0\xcc" \ + "\x82\x4f\xfa\x3d\xa9\x43\xfb\xe2\x4b\x8b\x77\xc1\x45\x77\x7c\xaf" \ + "\x5b\x0b\x73\xd2\x9a\xc1\x54\x36\x35\x17\x18\xdc\xd3\xd5\xe7\xa0" \ + "\x1c\x05\x6a\x49\xff\x89\x1c\x71\x75\xc8\xa6\x5a\xf6\xb3\x13\x11" \ + "\x50\xda\x7b\xb9\xf9\x23\x58\xfa\xba\x45\x0d\xcd\xe1\x58\x44\x98" \ + "\x5d\x73\x28\x26\xe9\xcd\x5e\xb9\x14\xa7\xab\x4e\x06\xe7\x18\x3e" \ + "\xae\xe9\x8d\x34\xba\xd7\xb9\x52\x89\x8e\xfc\x05\xad\x90\xc1\x00" \ + "\xa4\x21\xbb\x57\x45\x7d\x7e\xfa\xd1\x13\xb5\x38\x51\xd1\xd9\xef" \ + "\xa1\xec\x2a\x6a\xa4\x3d\xda\xb5\xd3\x61\x48\xc4\x74\xff\x95\xd0" \ + "\x8f\xe6\x19\xc6\x51\xc2\x18\x44\xfe\x35\x74\xe4\x76\xb9\xed\x69" \ + "\xf2\x76\x89\x57\xa0\x8c\x94\x61\xcd\xcf\x66\x5c\xca\x15\xe5\x5c" \ + "\x80\xfb\xb5\x92\xd2\xe4\x73\x32\xc4\x0d\x85\x97\xf4\x3d\x40\x83" \ + "\x8e\x7c\x3e\x17\x04\xed\x8f\xc4\x27\xc5\x0f\x78\xd1\x6c\x09\x5e" \ + "\x0e\xf3\x57\x81\x99\xe4\x7f\xef\x9e\xa5\xac\x3c\xd7\x43\x54\xf7" \ + "\x44\xb6\xa7\x94\xc3\xc8\x43\xae\x40\x50\xe8\x34\x16\x57\xf5\xfa" \ + "\xa8\xb1\xd5\x90\xbb\x5b\xa8\x3b\x68\x0d\x83\x56\xdc\xed\x2b\xbb" \ + "\x37\x7f\xd5\xfe\xc6\x47\x3c\xab\x89\x7a\x3c\x72\xe3\x52\x55\x07" \ + "\xea\xb1\x8a\xa8\xed\x39\x9a\x33\x81\x39\x5c\x42\xd7\xbe\x92\x39" \ + "\x5d\x5d\xd2\x67\x43\xd4\x42\x19\x69\x9f\x97\x1f\x2c\x0b\xf4\xfd" \ + "\x9d\xa6\x93\x7d\x56\xcd\x64\x22\x08\x97\x13\xd0\x4b\x9d\xf9\x5d" \ + "\xed\xc5\xca\xbd\x0c\xc4\x66\x64\x31\x9d\x85\xd6\xf4\x94\x2a\x7f" \ + "\xf4\x52\x77\x74\xb8\xdd\xf1\xea\x77\xc9\x23\x18\x6f\x02\xbd\xc5" \ + "\xe1\xda\xe0\x84\x40\x37\x6a\x3f\x32\x30\xac\xee\xaa\xbd\xcc\xf0" \ + "\xb8\x4d\x81\xb4\xc2\x6b\x40\xc0\xe3\xd1\x06\x1b\x1c\xcc\x4d\x0f" \ + "\x0a\xd0\x7e\x25\x41\x07\x71\x94\x3e\xeb\xc1\xd4\xc9\x94\xf6\x25" \ + "\x00\x3d\xc0\x2e\xee\x2e\xfa\x36\x63\x64\x08\xde\x3c\x21\xcc\x58" \ + "\x03\x48\x9f\x14\xc3\x01\x1e\x46\x8f\x28\x50\x84\x3d\xfb\x93\x8b" \ + "\xca\xf2\x4b\x56\xe6\xd8\xf0\xcb\x03\x6a\x42\x01\xf5\xc0\x98\x23" \ + "\x77\x9f\x6e\x7c\xe9\x54\xe2\x04\x6e\xa4\xe2\x4e\x91\x46\xed\xaa" \ + "\xd7\x31\x76\xa1\x7e\x93\x1c\x3b\x88\x2f\xfc\xc3\x3c\x2e\x5c\x62" \ + "\x87\x5f\xc7\x29\x24\x59\xc2\x08\xd3\x76\xa1\x9e\x67\xd3\xf3\x68" \ + "\x37\xd8\x71\xfd\xab\xee\xab\xae\xcd\x4b\x50\x42\x58\xd4\x42\xc2" \ + "\xfe\xae\x7e\x9e\x7b\x87\x22\x65\xfb\x8b\x90\x7a\xb1\x7e\x96\x51" \ + "\xaa\xf3\xa8\x89\xdf\xd5\x7e\xa5\xb2\x88\x19\xca\x49\xfd\x19\xb2" \ + "\xc0\x7c\x89\x61\xa9\x09\xd6\x76\xb2\x95\x7a\x1d\xe7\x3d\x27\x63" \ + "\x15\xde\x09\xeb\xce\x6a\x6a\xdb\x2f\xca\x42\x34\x73\x41\x01\x34" \ + "\xfa\x74\xa5\xeb\xee\x69\x8e\x1d\x55\x15\xf1\x94\x84\xac\xd2\x16" \ + "\xdb\xc9\xea\xa9\x14\xf4\x96\x1e\x1a\x8a\xdd\x14\xbd\x8b\x7c\x31" \ + "\xb5\xa2\xd4\x39\x48\x08\x98\x3a\x79\x41\x61\x33\xc9\x5b\x0a\x19" \ + "\x86\xd3\x90\x43\xf3\x79\xef\xde\x34\x05\x02\x42\xa1\xe9\x30\x4d" \ + "\x0e\xf9\x79\x4b\xb0\xa5\x0e\x2d\xc9\x11\xc6\x69\xbe\x8d\xb8\x09" \ + "\x1d\xc5\xae\x0b\xdd\x79\x77\xf8\x2f\x68\x9a\xd5\x85\x3e\x62\xe3" \ + "\xfd\x2b\x28\x0f\x99\xec\x83\x2d\x7d\x01\x0c\x15\xe9\xa8\xc5\xaa" \ + "\x29\xea\xa0\x3c\x62\x9e\x42\xf3\x77\xed\x09\x37\x05\xa2\x46\x5c" \ + "\xcf\x48\x40\x1b\x16\xcf\xe7\x0f\xc2\x59\x1f\xd3\xdc\xae\x99\x76" \ + "\xfc\xfb\xf0\x08\xe7\xfc\x83\xe8\xa1\x4c\x94\x58\xae\xf6\x59\x01" \ + "\x06\xd9\xb6\xd1\xd8\x70\x64\xff\xd0\xb1\x8e\xd5\xdd\x5a\xa1\xb6" \ + "\x79\xb5\x32\xa8\xf8\xd7\xe0\x95\x2a\x78\x53\x64\x20\x54\xfd\xcd" \ + "\x81\x73\xf4\x89\x00\x99\x39\x7b\x7e\x97\x39\xe1\x07\x77\x0e\xc8" \ + "\x95\x91\xc6\x24\x9e\x62\x5b\x7b\x7f\xf5\x29\xcc\xd2\x92\x46\x8a" \ + "\xce\x4c\x33\xd0\x20\xa7\x69\x15\xff\x4b\x6c\x7b\x09\xb8\xd9\x5c" \ + "\xa9\x1d\x8e\x0f\xd2\x8d\x5d\x2d\x31\x07\x7a\xaf\x0c\x6e\x3e\x15" \ + "\xf6\xa9\xf1\x3b\x20\xc3\xb9\x16\xbd\x04\x99\xeb\xcd\x5a\x08\x9f" \ + "\x02\x4b\x77\xc6\xbf\xc2\x8b\x00\x0e\xd8\xc0\xe0\x41\x4c\xcf\xda" \ + "\xa2\x77\xbb\x6b\x25\xfe\xf0\xa0\x13\x4e\x88\x87\x14\xc7\xe5\x22" \ + "\xa0\x18\x6b\x55\xee\xdf\x7f\x14\x73\xee\x4c\x04\x0b\xb3\xe6\xe4" \ + "\xf3\x00\x2e\x31\x46\x40\x5c\x69\xa2\xd4\x82\xac\xe1\x0a\xc3\x77" \ + "\x0a\x3a\x17\x72\xdd\xae\x43\x0f\xf7\x86\x1d\xb2\x38\x65\xa2\x64" \ + "\x75\xaf\x0e\x3a\x28\xed\x60\x32\xe5\x91\x4f\x68\xb8\xbf\x82\xf3" \ + "\x26\x40\x58\xe3\x92\x9b\x10\xb0\x52\x23\x0f\x76\xb2\x95\x10\xb6" \ + "\x74\x6d\xbf\x1d\xbf\x4a\xda\xb5\xc9\x06\xa5\xe8\x63\x2a\x66\xec" \ + "\x14\xb9\xd3\xe6\x93\x3d\x21\x56\x60\xb7\x3a\x75\xf7\xd7\x1e\x2f" \ + "\x25\x2d\x90\xb4\xf1\x3d\x92\x96\x28\x5c\x5b\x12\x05\xc4\x39\x1b" \ + "\x0d\x85\x10\x7f\xc0\x5a\x27\x76\x4a\x6f\xf8\x2d\x01\x85\x87\xef" \ + "\x07\xe1\xb1\x60\x0f\x0e\x06\xee\x7d\xf7\x62\x5a\xca\xa4\x9b\x4a" \ + "\x1c\x54\xe3\x1c\xfd\x39\x8c\xa4\x0b\x9e\x88\xf6\x3d\xed\xaf\xc2" \ + "\x86\x11\x88\xdf\x66\x6f\xce\x3e\x5a\xb0\xc5\xd9\xda\x13\x67\x92" \ + "\xd4\xc6\xd5\x55\xcf\x49\xdd\xb0\xbb\xb8\x2f\xbe\x47\x02\xe7\x58" \ + "\x9d\xc8\xd1\xe8\x89\x6d\x19\x38\xd3\xf4\x3f\x29\x2d\x61\x3a\xd5" \ + "\xf4\x22\x01\xfe\x0e\x21\xb2\xf0\x7e\x74\xb2\x33\x60\x3a\xc7\x5c" \ + "\x91\xeb\x99\x23\xe5\xd8\x9e\xec\xe3\x86\x9d\x1a\x6a\xed\xfa\xfc" \ + "\x0c\xbb\x33\x7c\x7d\x82\x3c\xde\xe4\xca\x7a\xef\xdc\x11\x13\x66" \ + "\xc7\x4c\x02\x48\xda\x10\x12\x31\xcf\x03\xa6\xa7\x31\x24\x61\x19" \ + "\x62\xf7\x3a\xf2\x31\x33\x90\x4b\x27\x56\x2c\x57\xf9\x3a\xd4\x0e" \ + "\xef\xc2\x0e\x58\x57\xb0\x21\x4f\xb8\xf4\x9d\x97\xa2\x35\xf0\x66" \ + "\x5a\xb2\xc1\xee\x97\x9b\x4a\x76\xf4\x5a\xa9\x74\x22\xf6\xe3\x26" \ + "\x44\x2a\xbc\x83\xaa\x31\x3a\x9f\x78\x9c\xba\x06\xba\x30\xb2\xaf" \ + "\x4a\x39\xa5\x4c\x41\x58\xb0\x75\x47\x3f\x13\xfc\x37\xd8\xc2\x85" \ + "\x4d\x0c\x7e\x61\xc5\x94\xdd\x1d\x7e\x01\xf0\x6e\x90\xde\xc6\x8d" \ + "\xa0\x21\xc2\x54\xd3\x53\xa8\x04\x3f\x30\x0d\x24\x27\xfa\x75\x76" \ + "\x79\x3c\x20\xc1\xa0\x26\xbb\x29\x38\x82\x93\x1f\x91\x30\xff\x42" \ + "\x1b\xbf\x13\x37\xb1\x05\x08\xe2\x58\x09\xdd\xa6\x4b\xfc\xef\xbd" \ + "\xdd\x4b\x37\x20\xf0\x69\xf5\xb3\x84\x4f\x81\x90\xe6\x0d\x14\x04" \ + "\xf8\x5d\x43\x4a\xf2\x8f\x82\x2d\xa3\xd0\x39\xbb\x3c\xd5\x0a\xd0" \ + "\xd8\xb7\xeb\xd7\x3f\x2e\x9d\x0a\x47\xa5\x5e\x24\xad\xaa\x46\xba" \ + "\x53\x72\xd2\xa4\xda\xfd\x56\x19\xce\x84\x13\xf2\xe9\xc3\xf1\xe6" \ + "\x14\x7c\xbd\x17\x93\x30\x59\x86\x5c\x86\x29\x70\x27\xe5\xe1\x13" \ + "\x86\xa6\xd2\x1e\xa5\xb9\xee\xcc\xe8\x2a\x3c\xf2\xb4\x7c\xf4\xdf" \ + "\xee\xb8\x9f\xbf\x8d\x8c\x21\xeb\x9b\x57\x23\x2f\xc7\xce\xea\x0e" \ + "\x55\x35\x94\xae\xf8\x43\xe0\x54\xec\xb3\x88\x02\xd5\xaa\x8d\x37" \ + "\xad\x15\x52\x96\xc9\xaa\x25\xd6\x36\x55\x46\x37\x9a\xcc\xa8\xbd" diff --git a/test/data/fle2-insert-range/decimal128/cmd.json b/test/data/fle2-insert-range/decimal128/cmd.json new file mode 100644 index 000000000..60373ded7 --- /dev/null +++ b/test/data/fle2-insert-range/decimal128/cmd.json @@ -0,0 +1,9 @@ +{ + "insert": "test", + "documents": [ + { + "plainText": "sample", + "encrypted": {"$numberDecimal":"1.23000000000000"} + } + ] +} diff --git a/test/data/fle2-insert-range/decimal128/encrypted-field-map.json b/test/data/fle2-insert-range/decimal128/encrypted-field-map.json new file mode 100644 index 000000000..a2068cd27 --- /dev/null +++ b/test/data/fle2-insert-range/decimal128/encrypted-field-map.json @@ -0,0 +1,28 @@ +{ + "db.test": { + "escCollection": "fle2.test.esc", + "eccCollection": "fle2.test.ecc", + "ecocCollection": "fle2.test.ecoc", + "fields": [ + { + "keyId": { + "$binary": { + "base64": "EjRWeBI0mHYSNBI0VniQEg==", + "subType": "04" + } + }, + "path": "encrypted", + "bsonType": "decimal", + "queries": { + "queryType": "rangePreview", + "contention": { + "$numberInt": "0" + }, + "sparsity": { + "$numberInt": "1" + } + } + } + ] + } +} diff --git a/test/data/fle2-insert-range/decimal128/encrypted-payload.json b/test/data/fle2-insert-range/decimal128/encrypted-payload.json new file mode 100644 index 000000000..963d6a075 --- /dev/null +++ b/test/data/fle2-insert-range/decimal128/encrypted-payload.json @@ -0,0 +1,45 @@ +{ + "insert": "test", + "documents": [ + { + "plainText": "sample", + "encrypted": { + "$binary": { + "base64": "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", + "subType": "6" + } + } + } + ], + "encryptionInformation": { + "type": 1, + "schema": { + "db.test": { + "escCollection": "fle2.test.esc", + "eccCollection": "fle2.test.ecc", + "ecocCollection": "fle2.test.ecoc", + "fields": [ + { + "keyId": { + "$binary": { + "base64": "EjRWeBI0mHYSNBI0VniQEg==", + "subType": "04" + } + }, + "path": "encrypted", + "bsonType": "decimal", + "queries": { + "queryType": "rangePreview", + "contention": { + "$numberInt": "0" + }, + "sparsity": { + "$numberInt": "1" + } + } + } + ] + } + } + } +} diff --git a/test/data/fle2-insert-range/decimal128/mongocryptd-reply.json b/test/data/fle2-insert-range/decimal128/mongocryptd-reply.json new file mode 100644 index 000000000..02767935e --- /dev/null +++ b/test/data/fle2-insert-range/decimal128/mongocryptd-reply.json @@ -0,0 +1,53 @@ +{ + "ok": { + "$numberInt": "1" + }, + "result": { + "insert": "test", + "documents": [ + { + "plainText": "sample", + "encrypted": { + "$binary": { + "base64": "A6EAAAAQdAABAAAAEGEAAwAAAAVraQAQAAAABBI0VngSNJh2EjQSNFZ4kBIFa3UAEAAAAASrze+rEjSYdhI0EjRWeJASA3YAQgAAABN2AACwTivebwAAAAAAAAAAJDATbWluAP////9jjo03wIetvgnt/98TbWF4AP////9jjo03wIetvgnt/18AEmNtAAAAAAAAAAAAEnMAAQAAAAAAAAAA", + "subType": "6" + } + } + } + ], + "encryptionInformation": { + "type": { + "$numberInt": "1" + }, + "schema": { + "db.test": { + "escCollection": "fle2.test.esc", + "eccCollection": "fle2.test.ecc", + "ecocCollection": "fle2.test.ecoc", + "fields": [ + { + "keyId": { + "$binary": { + "base64": "EjRWeBI0mHYSNBI0VniQEg==", + "subType": "04" + } + }, + "path": "encrypted", + "bsonType": "decimal", + "queries": { + "queryType": "rangePreview", + "contention": { + "$numberInt": "0" + }, + "sparsity": { + "$numberInt": "1" + } + } + } + ] + } + } + } + }, + "hasEncryptedPlaceholders": true +} \ No newline at end of file diff --git a/test/data/range-edge-generation/edges_decimal128.cstruct b/test/data/range-edge-generation/edges_decimal128.cstruct new file mode 100644 index 000000000..e2f5a982f --- /dev/null +++ b/test/data/range-edge-generation/edges_decimal128.cstruct @@ -0,0 +1,14527 @@ +// This code is GENERATED! Do not edit! +// clang-format off +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 1, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1", + "10", + "100", + "1000", + "10000", + "100000", + "1000000", + "10000000", + "100000000", + "1000000000", + "10000000000", + "100000000000", + "1000000000000", + "10000000000000", + "100000000000000", + "1000000000000000", + "10000000000000000", + "100000000000000000", + "1000000000000000000", + "10000000000000000000", + "100000000000000000000", + "1000000000000000000000", + "10000000000000000000000", + "100000000000000000000000", + "1000000000000000000000000", + "10000000000000000000000000", + "100000000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000", + "1000000000000000000000000000000000", + "10000000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 2, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10", + "1000", + "100000", + "10000000", + "1000000000", + "100000000000", + "10000000000000", + "1000000000000000", + "100000000000000000", + "10000000000000000000", + "1000000000000000000000", + "100000000000000000000000", + "10000000000000000000000000", + "1000000000000000000000000000", + "100000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000", + "100000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 3, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100", + "100000", + "100000000", + "100000000000", + "100000000000000", + "100000000000000000", + "100000000000000000000", + "100000000000000000000000", + "100000000000000000000000000", + "100000000000000000000000000000", + "100000000000000000000000000000000", + "100000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 4, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000", + "10000000", + "100000000000", + "1000000000000000", + "10000000000000000000", + "100000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 8, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000", + "1000000000000000", + "100000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 10, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000", + "10000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 11, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000", + "1000000000000000000000", + "100000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 16, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 31, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 32, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 1, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1", + "10", + "100", + "1000", + "10000", + "100000", + "1000000", + "10000000", + "100000000", + "1000000000", + "10000000000", + "100000000000", + "1000000000000", + "10000000000000", + "100000000000000", + "1000000000000000", + "10000000000000000", + "100000000000000000", + "1000000000000000000", + "10000000000000000000", + "100000000000000000000", + "1000000000000000000000", + "10000000000000000000000", + "100000000000000000000000", + "1000000000000000000000000", + "10000000000000000000000000", + "100000000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000", + "1000000000000000000000000000000000", + "10000000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 2, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10", + "1000", + "100000", + "10000000", + "1000000000", + "100000000000", + "10000000000000", + "1000000000000000", + "100000000000000000", + "10000000000000000000", + "1000000000000000000000", + "100000000000000000000000", + "10000000000000000000000000", + "1000000000000000000000000000", + "100000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000", + "100000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 3, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100", + "100000", + "100000000", + "100000000000", + "100000000000000", + "100000000000000000", + "100000000000000000000", + "100000000000000000000000", + "100000000000000000000000000", + "100000000000000000000000000000", + "100000000000000000000000000000000", + "100000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 4, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000", + "10000000", + "100000000000", + "1000000000000000", + "10000000000000000000", + "100000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 8, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000", + "1000000000000000", + "100000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 10, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000", + "10000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 11, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000", + "1000000000000000000000", + "100000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 16, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 31, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 32, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 1, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1", + "10", + "100", + "1000", + "10000", + "100000", + "1000000", + "10000000", + "100000000", + "1000000000", + "10000000000", + "100000000000", + "1000000000000", + "10000000000000", + "100000000000000", + "1000000000000000", + "10000000000000000", + "100000000000000000", + "1000000000000000000", + "10000000000000000000", + "100000000000000000000", + "1000000000000000000000", + "10000000000000000000000", + "100000000000000000000000", + "1000000000000000000000000", + "10000000000000000000000000", + "100000000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000", + "1000000000000000000000000000000000", + "10000000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 2, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10", + "1000", + "100000", + "10000000", + "1000000000", + "100000000000", + "10000000000000", + "1000000000000000", + "100000000000000000", + "10000000000000000000", + "1000000000000000000000", + "100000000000000000000000", + "10000000000000000000000000", + "1000000000000000000000000000", + "100000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000", + "100000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 3, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100", + "100000", + "100000000", + "100000000000", + "100000000000000", + "100000000000000000", + "100000000000000000000", + "100000000000000000000000", + "100000000000000000000000000", + "100000000000000000000000000000", + "100000000000000000000000000000000", + "100000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 4, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000", + "10000000", + "100000000000", + "1000000000000000", + "10000000000000000000", + "100000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 8, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000", + "1000000000000000", + "100000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 10, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000", + "10000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 11, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000", + "1000000000000000000000", + "100000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 16, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 31, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 32, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 1, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1", + "10", + "100", + "1000", + "10000", + "100000", + "1000000", + "10000000", + "100000000", + "1000000000", + "10000000000", + "100000000000", + "1000000000000", + "10000000000000", + "100000000000000", + "1000000000000000", + "10000000000000000", + "100000000000000000", + "1000000000000000000", + "10000000000000000000", + "100000000000000000000", + "1000000000000000000000", + "10000000000000000000000", + "100000000000000000000000", + "1000000000000000000000000", + "10000000000000000000000000", + "100000000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000", + "1000000000000000000000000000000000", + "10000000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 2, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10", + "1000", + "100000", + "10000000", + "1000000000", + "100000000000", + "10000000000000", + "1000000000000000", + "100000000000000000", + "10000000000000000000", + "1000000000000000000000", + "100000000000000000000000", + "10000000000000000000000000", + "1000000000000000000000000000", + "100000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000", + "100000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 3, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100", + "100000", + "100000000", + "100000000000", + "100000000000000", + "100000000000000000", + "100000000000000000000", + "100000000000000000000000", + "100000000000000000000000000", + "100000000000000000000000000000", + "100000000000000000000000000000000", + "100000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 4, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000", + "10000000", + "100000000000", + "1000000000000000", + "10000000000000000000", + "100000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 8, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000", + "1000000000000000", + "100000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 10, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000", + "10000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 11, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000", + "1000000000000000000000", + "100000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 16, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 31, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 32, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 1, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1", + "10", + "100", + "1000", + "10000", + "100000", + "1000000", + "10000000", + "100000000", + "1000000000", + "10000000000", + "100000000000", + "1000000000000", + "10000000000000", + "100000000000000", + "1000000000000000", + "10000000000000000", + "100000000000000000", + "1000000000000000000", + "10000000000000000000", + "100000000000000000000", + "1000000000000000000000", + "10000000000000000000000", + "100000000000000000000000", + "1000000000000000000000000", + "10000000000000000000000000", + "100000000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000", + "1000000000000000000000000000000000", + "10000000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 2, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10", + "1000", + "100000", + "10000000", + "1000000000", + "100000000000", + "10000000000000", + "1000000000000000", + "100000000000000000", + "10000000000000000000", + "1000000000000000000000", + "100000000000000000000000", + "10000000000000000000000000", + "1000000000000000000000000000", + "100000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000", + "100000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 3, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100", + "100000", + "100000000", + "100000000000", + "100000000000000", + "100000000000000000", + "100000000000000000000", + "100000000000000000000000", + "100000000000000000000000000", + "100000000000000000000000000000", + "100000000000000000000000000000000", + "100000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 4, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000", + "10000000", + "100000000000", + "1000000000000000", + "10000000000000000000", + "100000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 8, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000", + "1000000000000000", + "100000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 10, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000", + "10000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 11, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000", + "1000000000000000000000", + "100000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 16, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 31, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 32, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 1, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1", + "10", + "100", + "1000", + "10000", + "100000", + "1000000", + "10000000", + "100000000", + "1000000000", + "10000000000", + "100000000000", + "1000000000000", + "10000000000000", + "100000000000000", + "1000000000000000", + "10000000000000000", + "100000000000000000", + "1000000000000000000", + "10000000000000000000", + "100000000000000000000", + "1000000000000000000000", + "10000000000000000000000", + "100000000000000000000000", + "1000000000000000000000000", + "10000000000000000000000000", + "100000000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000", + "1000000000000000000000000000000000", + "10000000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 2, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10", + "1000", + "100000", + "10000000", + "1000000000", + "100000000000", + "10000000000000", + "1000000000000000", + "100000000000000000", + "10000000000000000000", + "1000000000000000000000", + "100000000000000000000000", + "10000000000000000000000000", + "1000000000000000000000000000", + "100000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000", + "100000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 3, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100", + "100000", + "100000000", + "100000000000", + "100000000000000", + "100000000000000000", + "100000000000000000000", + "100000000000000000000000", + "100000000000000000000000000", + "100000000000000000000000000000", + "100000000000000000000000000000000", + "100000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 4, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000", + "10000000", + "100000000000", + "1000000000000000", + "10000000000000000000", + "100000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 8, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000", + "1000000000000000", + "100000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 10, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000", + "10000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 11, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000", + "1000000000000000000000", + "100000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 16, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 31, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 32, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 1, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1", + "10", + "100", + "1000", + "10000", + "100000", + "1000000", + "10000000", + "100000000", + "1000000000", + "10000000000", + "100000000000", + "1000000000000", + "10000000000000", + "100000000000000", + "1000000000000000", + "10000000000000000", + "100000000000000000", + "1000000000000000000", + "10000000000000000000", + "100000000000000000000", + "1000000000000000000000", + "10000000000000000000000", + "100000000000000000000000", + "1000000000000000000000000", + "10000000000000000000000000", + "100000000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000", + "1000000000000000000000000000000000", + "10000000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 2, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10", + "1000", + "100000", + "10000000", + "1000000000", + "100000000000", + "10000000000000", + "1000000000000000", + "100000000000000000", + "10000000000000000000", + "1000000000000000000000", + "100000000000000000000000", + "10000000000000000000000000", + "1000000000000000000000000000", + "100000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000", + "100000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 3, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100", + "100000", + "100000000", + "100000000000", + "100000000000000", + "100000000000000000", + "100000000000000000000", + "100000000000000000000000", + "100000000000000000000000000", + "100000000000000000000000000000", + "100000000000000000000000000000000", + "100000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 4, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000", + "10000000", + "100000000000", + "1000000000000000", + "10000000000000000000", + "100000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 8, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000", + "1000000000000000", + "100000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 10, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000", + "10000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 11, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000", + "1000000000000000000000", + "100000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 16, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 31, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 32, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 1, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1", + "10", + "100", + "1000", + "10000", + "100000", + "1000000", + "10000000", + "100000000", + "1000000000", + "10000000000", + "100000000000", + "1000000000000", + "10000000000000", + "100000000000000", + "1000000000000000", + "10000000000000000", + "100000000000000000", + "1000000000000000000", + "10000000000000000000", + "100000000000000000000", + "1000000000000000000000", + "10000000000000000000000", + "100000000000000000000000", + "1000000000000000000000000", + "10000000000000000000000000", + "100000000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000", + "1000000000000000000000000000000000", + "10000000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 2, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10", + "1000", + "100000", + "10000000", + "1000000000", + "100000000000", + "10000000000000", + "1000000000000000", + "100000000000000000", + "10000000000000000000", + "1000000000000000000000", + "100000000000000000000000", + "10000000000000000000000000", + "1000000000000000000000000000", + "100000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000", + "100000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 3, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100", + "100000", + "100000000", + "100000000000", + "100000000000000", + "100000000000000000", + "100000000000000000000", + "100000000000000000000000", + "100000000000000000000000000", + "100000000000000000000000000000", + "100000000000000000000000000000000", + "100000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 4, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000", + "10000000", + "100000000000", + "1000000000000000", + "10000000000000000000", + "100000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 8, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000", + "1000000000000000", + "100000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 10, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000", + "10000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 11, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000", + "1000000000000000000000", + "100000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 16, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 31, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 32, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 1, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1", + "10", + "100", + "1000", + "10000", + "100000", + "1000000", + "10000000", + "100000000", + "1000000000", + "10000000000", + "100000000000", + "1000000000000", + "10000000000000", + "100000000000000", + "1000000000000000", + "10000000000000000", + "100000000000000000", + "1000000000000000000", + "10000000000000000000", + "100000000000000000000", + "1000000000000000000000", + "10000000000000000000000", + "100000000000000000000000", + "1000000000000000000000000", + "10000000000000000000000000", + "100000000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000", + "1000000000000000000000000000000000", + "10000000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 2, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10", + "1000", + "100000", + "10000000", + "1000000000", + "100000000000", + "10000000000000", + "1000000000000000", + "100000000000000000", + "10000000000000000000", + "1000000000000000000000", + "100000000000000000000000", + "10000000000000000000000000", + "1000000000000000000000000000", + "100000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000", + "100000000000000000000000000000000000", + "10000000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 3, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100", + "100000", + "100000000", + "100000000000", + "100000000000000", + "100000000000000000", + "100000000000000000000", + "100000000000000000000000", + "100000000000000000000000000", + "100000000000000000000000000000", + "100000000000000000000000000000000", + "100000000000000000000000000000000000", + "100000000000000000000000000000000000000", + "100000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 4, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000", + "10000000", + "100000000000", + "1000000000000000", + "10000000000000000000", + "100000000000000000000000", + "1000000000000000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 8, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000", + "1000000000000000", + "100000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 10, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000", + "10000000000000000000", + "100000000000000000000000000000", + "1000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 11, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000", + "1000000000000000000000", + "100000000000000000000000000000000", + "10000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 16, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000", + "10000000000000000000000000000000", + "100000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 31, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128(0), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 32, + .expectEdges = { + "root", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000", + "1000000000000000000000000000000000000000000000000000000000000000", + "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 1, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0", + "01", + "010", + "0101", + "01010", + "010100", + "0101000", + "01010001", + "010100011", + "0101000111", + "01010001110", + "010100011100", + "0101000111001", + "01010001110011", + "010100011100110", + "0101000111001101", + "01010001110011010", + "010100011100110101", + "0101000111001101011", + "01010001110011010111", + "010100011100110101110", + "0101000111001101011100", + "01010001110011010111000", + "010100011100110101110001", + "0101000111001101011100010", + "01010001110011010111000100", + "010100011100110101110001001", + "0101000111001101011100010010", + "01010001110011010111000100100", + "010100011100110101110001001001", + "0101000111001101011100010010011", + "01010001110011010111000100100110", + "010100011100110101110001001001100", + "0101000111001101011100010010011001", + "01010001110011010111000100100110010", + "010100011100110101110001001001100100", + "0101000111001101011100010010011001001", + "01010001110011010111000100100110010010", + "010100011100110101110001001001100100101", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100", + "010100011100110101110001001001100100101000", + "0101000111001101011100010010011001001010000", + "01010001110011010111000100100110010010100001", + "010100011100110101110001001001100100101000011", + "0101000111001101011100010010011001001010000111", + "01010001110011010111000100100110010010100001110", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000", + "01010001110011010111000100100110010010100001110000", + "010100011100110101110001001001100100101000011100001", + "0101000111001101011100010010011001001010000111000011", + "01010001110011010111000100100110010010100001110000111", + "010100011100110101110001001001100100101000011100001110", + "0101000111001101011100010010011001001010000111000011101", + "01010001110011010111000100100110010010100001110000111010", + "010100011100110101110001001001100100101000011100001110101", + "0101000111001101011100010010011001001010000111000011101011", + "01010001110011010111000100100110010010100001110000111010110", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000", + "01010001110011010111000100100110010010100001110000111010110001", + "010100011100110101110001001001100100101000011100001110101100010", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010", + "010100011100110101110001001001100100101000011100001110101100010100", + "0101000111001101011100010010011001001010000111000011101011000101000", + "01010001110011010111000100100110010010100001110000111010110001010000", + "010100011100110101110001001001100100101000011100001110101100010100001", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "01010001110011010111000100100110010010100001110000111010110001010000101", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "0101000111001101011100010010011001001010000111000011101011000101000010111", + "01010001110011010111000100100110010010100001110000111010110001010000101110", + "010100011100110101110001001001100100101000011100001110101100010100001011100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111110", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 2, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01", + "0101", + "010100", + "01010001", + "0101000111", + "010100011100", + "01010001110011", + "0101000111001101", + "010100011100110101", + "01010001110011010111", + "0101000111001101011100", + "010100011100110101110001", + "01010001110011010111000100", + "0101000111001101011100010010", + "010100011100110101110001001001", + "01010001110011010111000100100110", + "0101000111001101011100010010011001", + "010100011100110101110001001001100100", + "01010001110011010111000100100110010010", + "0101000111001101011100010010011001001010", + "010100011100110101110001001001100100101000", + "01010001110011010111000100100110010010100001", + "0101000111001101011100010010011001001010000111", + "010100011100110101110001001001100100101000011100", + "01010001110011010111000100100110010010100001110000", + "0101000111001101011100010010011001001010000111000011", + "010100011100110101110001001001100100101000011100001110", + "01010001110011010111000100100110010010100001110000111010", + "0101000111001101011100010010011001001010000111000011101011", + "010100011100110101110001001001100100101000011100001110101100", + "01010001110011010111000100100110010010100001110000111010110001", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100", + "01010001110011010111000100100110010010100001110000111010110001010000", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "01010001110011010111000100100110010010100001110000111010110001010000101110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 3, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "010", + "010100", + "010100011", + "010100011100", + "010100011100110", + "010100011100110101", + "010100011100110101110", + "010100011100110101110001", + "010100011100110101110001001", + "010100011100110101110001001001", + "010100011100110101110001001001100", + "010100011100110101110001001001100100", + "010100011100110101110001001001100100101", + "010100011100110101110001001001100100101000", + "010100011100110101110001001001100100101000011", + "010100011100110101110001001001100100101000011100", + "010100011100110101110001001001100100101000011100001", + "010100011100110101110001001001100100101000011100001110", + "010100011100110101110001001001100100101000011100001110101", + "010100011100110101110001001001100100101000011100001110101100", + "010100011100110101110001001001100100101000011100001110101100010", + "010100011100110101110001001001100100101000011100001110101100010100", + "010100011100110101110001001001100100101000011100001110101100010100001", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "010100011100110101110001001001100100101000011100001110101100010100001011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 4, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101", + "01010001", + "010100011100", + "0101000111001101", + "01010001110011010111", + "010100011100110101110001", + "0101000111001101011100010010", + "01010001110011010111000100100110", + "010100011100110101110001001001100100", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100001", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000011", + "01010001110011010111000100100110010010100001110000111010", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010000", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 8, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001", + "0101000111001101", + "010100011100110101110001", + "01010001110011010111000100100110", + "0101000111001101011100010010011001001010", + "010100011100110101110001001001100100101000011100", + "01010001110011010111000100100110010010100001110000111010", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 10, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111", + "01010001110011010111", + "010100011100110101110001001001", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100001110000", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 11, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001110", + "0101000111001101011100", + "010100011100110101110001001001100", + "01010001110011010111000100100110010010100001", + "0101000111001101011100010010011001001010000111000011101", + "010100011100110101110001001001100100101000011100001110101100010100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 16, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111001101", + "01010001110011010111000100100110", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 31, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111001101011100010010011", + "01010001110011010111000100100110010010100001110000111010110001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 32, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001110011010111000100100110", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 1, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0", + "01", + "010", + "0101", + "01010", + "010100", + "0101000", + "01010001", + "010100011", + "0101000111", + "01010001110", + "010100011100", + "0101000111001", + "01010001110011", + "010100011100110", + "0101000111001101", + "01010001110011010", + "010100011100110101", + "0101000111001101011", + "01010001110011010111", + "010100011100110101110", + "0101000111001101011100", + "01010001110011010111000", + "010100011100110101110001", + "0101000111001101011100010", + "01010001110011010111000100", + "010100011100110101110001001", + "0101000111001101011100010010", + "01010001110011010111000100100", + "010100011100110101110001001001", + "0101000111001101011100010010011", + "01010001110011010111000100100110", + "010100011100110101110001001001100", + "0101000111001101011100010010011001", + "01010001110011010111000100100110010", + "010100011100110101110001001001100100", + "0101000111001101011100010010011001001", + "01010001110011010111000100100110010010", + "010100011100110101110001001001100100101", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100", + "010100011100110101110001001001100100101000", + "0101000111001101011100010010011001001010000", + "01010001110011010111000100100110010010100001", + "010100011100110101110001001001100100101000011", + "0101000111001101011100010010011001001010000111", + "01010001110011010111000100100110010010100001110", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000", + "01010001110011010111000100100110010010100001110000", + "010100011100110101110001001001100100101000011100001", + "0101000111001101011100010010011001001010000111000011", + "01010001110011010111000100100110010010100001110000111", + "010100011100110101110001001001100100101000011100001110", + "0101000111001101011100010010011001001010000111000011101", + "01010001110011010111000100100110010010100001110000111010", + "010100011100110101110001001001100100101000011100001110101", + "0101000111001101011100010010011001001010000111000011101011", + "01010001110011010111000100100110010010100001110000111010110", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000", + "01010001110011010111000100100110010010100001110000111010110001", + "010100011100110101110001001001100100101000011100001110101100010", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010", + "010100011100110101110001001001100100101000011100001110101100010100", + "0101000111001101011100010010011001001010000111000011101011000101000", + "01010001110011010111000100100110010010100001110000111010110001010000", + "010100011100110101110001001001100100101000011100001110101100010100001", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "01010001110011010111000100100110010010100001110000111010110001010000101", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "0101000111001101011100010010011001001010000111000011101011000101000010111", + "01010001110011010111000100100110010010100001110000111010110001010000101110", + "010100011100110101110001001001100100101000011100001110101100010100001011100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111110", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 2, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01", + "0101", + "010100", + "01010001", + "0101000111", + "010100011100", + "01010001110011", + "0101000111001101", + "010100011100110101", + "01010001110011010111", + "0101000111001101011100", + "010100011100110101110001", + "01010001110011010111000100", + "0101000111001101011100010010", + "010100011100110101110001001001", + "01010001110011010111000100100110", + "0101000111001101011100010010011001", + "010100011100110101110001001001100100", + "01010001110011010111000100100110010010", + "0101000111001101011100010010011001001010", + "010100011100110101110001001001100100101000", + "01010001110011010111000100100110010010100001", + "0101000111001101011100010010011001001010000111", + "010100011100110101110001001001100100101000011100", + "01010001110011010111000100100110010010100001110000", + "0101000111001101011100010010011001001010000111000011", + "010100011100110101110001001001100100101000011100001110", + "01010001110011010111000100100110010010100001110000111010", + "0101000111001101011100010010011001001010000111000011101011", + "010100011100110101110001001001100100101000011100001110101100", + "01010001110011010111000100100110010010100001110000111010110001", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100", + "01010001110011010111000100100110010010100001110000111010110001010000", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "01010001110011010111000100100110010010100001110000111010110001010000101110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 3, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "010", + "010100", + "010100011", + "010100011100", + "010100011100110", + "010100011100110101", + "010100011100110101110", + "010100011100110101110001", + "010100011100110101110001001", + "010100011100110101110001001001", + "010100011100110101110001001001100", + "010100011100110101110001001001100100", + "010100011100110101110001001001100100101", + "010100011100110101110001001001100100101000", + "010100011100110101110001001001100100101000011", + "010100011100110101110001001001100100101000011100", + "010100011100110101110001001001100100101000011100001", + "010100011100110101110001001001100100101000011100001110", + "010100011100110101110001001001100100101000011100001110101", + "010100011100110101110001001001100100101000011100001110101100", + "010100011100110101110001001001100100101000011100001110101100010", + "010100011100110101110001001001100100101000011100001110101100010100", + "010100011100110101110001001001100100101000011100001110101100010100001", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "010100011100110101110001001001100100101000011100001110101100010100001011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 4, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101", + "01010001", + "010100011100", + "0101000111001101", + "01010001110011010111", + "010100011100110101110001", + "0101000111001101011100010010", + "01010001110011010111000100100110", + "010100011100110101110001001001100100", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100001", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000011", + "01010001110011010111000100100110010010100001110000111010", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010000", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 8, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001", + "0101000111001101", + "010100011100110101110001", + "01010001110011010111000100100110", + "0101000111001101011100010010011001001010", + "010100011100110101110001001001100100101000011100", + "01010001110011010111000100100110010010100001110000111010", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 10, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111", + "01010001110011010111", + "010100011100110101110001001001", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100001110000", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 11, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001110", + "0101000111001101011100", + "010100011100110101110001001001100", + "01010001110011010111000100100110010010100001", + "0101000111001101011100010010011001001010000111000011101", + "010100011100110101110001001001100100101000011100001110101100010100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 16, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111001101", + "01010001110011010111000100100110", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 31, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111001101011100010010011", + "01010001110011010111000100100110010010100001110000111010110001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 32, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001110011010111000100100110", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 1, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0", + "01", + "010", + "0101", + "01010", + "010100", + "0101000", + "01010001", + "010100011", + "0101000111", + "01010001110", + "010100011100", + "0101000111001", + "01010001110011", + "010100011100110", + "0101000111001101", + "01010001110011010", + "010100011100110101", + "0101000111001101011", + "01010001110011010111", + "010100011100110101110", + "0101000111001101011100", + "01010001110011010111000", + "010100011100110101110001", + "0101000111001101011100010", + "01010001110011010111000100", + "010100011100110101110001001", + "0101000111001101011100010010", + "01010001110011010111000100100", + "010100011100110101110001001001", + "0101000111001101011100010010011", + "01010001110011010111000100100110", + "010100011100110101110001001001100", + "0101000111001101011100010010011001", + "01010001110011010111000100100110010", + "010100011100110101110001001001100100", + "0101000111001101011100010010011001001", + "01010001110011010111000100100110010010", + "010100011100110101110001001001100100101", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100", + "010100011100110101110001001001100100101000", + "0101000111001101011100010010011001001010000", + "01010001110011010111000100100110010010100001", + "010100011100110101110001001001100100101000011", + "0101000111001101011100010010011001001010000111", + "01010001110011010111000100100110010010100001110", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000", + "01010001110011010111000100100110010010100001110000", + "010100011100110101110001001001100100101000011100001", + "0101000111001101011100010010011001001010000111000011", + "01010001110011010111000100100110010010100001110000111", + "010100011100110101110001001001100100101000011100001110", + "0101000111001101011100010010011001001010000111000011101", + "01010001110011010111000100100110010010100001110000111010", + "010100011100110101110001001001100100101000011100001110101", + "0101000111001101011100010010011001001010000111000011101011", + "01010001110011010111000100100110010010100001110000111010110", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000", + "01010001110011010111000100100110010010100001110000111010110001", + "010100011100110101110001001001100100101000011100001110101100010", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010", + "010100011100110101110001001001100100101000011100001110101100010100", + "0101000111001101011100010010011001001010000111000011101011000101000", + "01010001110011010111000100100110010010100001110000111010110001010000", + "010100011100110101110001001001100100101000011100001110101100010100001", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "01010001110011010111000100100110010010100001110000111010110001010000101", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "0101000111001101011100010010011001001010000111000011101011000101000010111", + "01010001110011010111000100100110010010100001110000111010110001010000101110", + "010100011100110101110001001001100100101000011100001110101100010100001011100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111110", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 2, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01", + "0101", + "010100", + "01010001", + "0101000111", + "010100011100", + "01010001110011", + "0101000111001101", + "010100011100110101", + "01010001110011010111", + "0101000111001101011100", + "010100011100110101110001", + "01010001110011010111000100", + "0101000111001101011100010010", + "010100011100110101110001001001", + "01010001110011010111000100100110", + "0101000111001101011100010010011001", + "010100011100110101110001001001100100", + "01010001110011010111000100100110010010", + "0101000111001101011100010010011001001010", + "010100011100110101110001001001100100101000", + "01010001110011010111000100100110010010100001", + "0101000111001101011100010010011001001010000111", + "010100011100110101110001001001100100101000011100", + "01010001110011010111000100100110010010100001110000", + "0101000111001101011100010010011001001010000111000011", + "010100011100110101110001001001100100101000011100001110", + "01010001110011010111000100100110010010100001110000111010", + "0101000111001101011100010010011001001010000111000011101011", + "010100011100110101110001001001100100101000011100001110101100", + "01010001110011010111000100100110010010100001110000111010110001", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100", + "01010001110011010111000100100110010010100001110000111010110001010000", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "01010001110011010111000100100110010010100001110000111010110001010000101110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 3, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "010", + "010100", + "010100011", + "010100011100", + "010100011100110", + "010100011100110101", + "010100011100110101110", + "010100011100110101110001", + "010100011100110101110001001", + "010100011100110101110001001001", + "010100011100110101110001001001100", + "010100011100110101110001001001100100", + "010100011100110101110001001001100100101", + "010100011100110101110001001001100100101000", + "010100011100110101110001001001100100101000011", + "010100011100110101110001001001100100101000011100", + "010100011100110101110001001001100100101000011100001", + "010100011100110101110001001001100100101000011100001110", + "010100011100110101110001001001100100101000011100001110101", + "010100011100110101110001001001100100101000011100001110101100", + "010100011100110101110001001001100100101000011100001110101100010", + "010100011100110101110001001001100100101000011100001110101100010100", + "010100011100110101110001001001100100101000011100001110101100010100001", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "010100011100110101110001001001100100101000011100001110101100010100001011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 4, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101", + "01010001", + "010100011100", + "0101000111001101", + "01010001110011010111", + "010100011100110101110001", + "0101000111001101011100010010", + "01010001110011010111000100100110", + "010100011100110101110001001001100100", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100001", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000011", + "01010001110011010111000100100110010010100001110000111010", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010000", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 8, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001", + "0101000111001101", + "010100011100110101110001", + "01010001110011010111000100100110", + "0101000111001101011100010010011001001010", + "010100011100110101110001001001100100101000011100", + "01010001110011010111000100100110010010100001110000111010", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 10, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111", + "01010001110011010111", + "010100011100110101110001001001", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100001110000", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 11, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001110", + "0101000111001101011100", + "010100011100110101110001001001100", + "01010001110011010111000100100110010010100001", + "0101000111001101011100010010011001001010000111000011101", + "010100011100110101110001001001100100101000011100001110101100010100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 16, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111001101", + "01010001110011010111000100100110", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 31, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111001101011100010010011", + "01010001110011010111000100100110010010100001110000111010110001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 32, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001110011010111000100100110", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 1, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0", + "01", + "010", + "0101", + "01010", + "010100", + "0101000", + "01010001", + "010100011", + "0101000111", + "01010001110", + "010100011100", + "0101000111001", + "01010001110011", + "010100011100110", + "0101000111001101", + "01010001110011010", + "010100011100110101", + "0101000111001101011", + "01010001110011010111", + "010100011100110101110", + "0101000111001101011100", + "01010001110011010111000", + "010100011100110101110001", + "0101000111001101011100010", + "01010001110011010111000100", + "010100011100110101110001001", + "0101000111001101011100010010", + "01010001110011010111000100100", + "010100011100110101110001001001", + "0101000111001101011100010010011", + "01010001110011010111000100100110", + "010100011100110101110001001001100", + "0101000111001101011100010010011001", + "01010001110011010111000100100110010", + "010100011100110101110001001001100100", + "0101000111001101011100010010011001001", + "01010001110011010111000100100110010010", + "010100011100110101110001001001100100101", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100", + "010100011100110101110001001001100100101000", + "0101000111001101011100010010011001001010000", + "01010001110011010111000100100110010010100001", + "010100011100110101110001001001100100101000011", + "0101000111001101011100010010011001001010000111", + "01010001110011010111000100100110010010100001110", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000", + "01010001110011010111000100100110010010100001110000", + "010100011100110101110001001001100100101000011100001", + "0101000111001101011100010010011001001010000111000011", + "01010001110011010111000100100110010010100001110000111", + "010100011100110101110001001001100100101000011100001110", + "0101000111001101011100010010011001001010000111000011101", + "01010001110011010111000100100110010010100001110000111010", + "010100011100110101110001001001100100101000011100001110101", + "0101000111001101011100010010011001001010000111000011101011", + "01010001110011010111000100100110010010100001110000111010110", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000", + "01010001110011010111000100100110010010100001110000111010110001", + "010100011100110101110001001001100100101000011100001110101100010", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010", + "010100011100110101110001001001100100101000011100001110101100010100", + "0101000111001101011100010010011001001010000111000011101011000101000", + "01010001110011010111000100100110010010100001110000111010110001010000", + "010100011100110101110001001001100100101000011100001110101100010100001", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "01010001110011010111000100100110010010100001110000111010110001010000101", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "0101000111001101011100010010011001001010000111000011101011000101000010111", + "01010001110011010111000100100110010010100001110000111010110001010000101110", + "010100011100110101110001001001100100101000011100001110101100010100001011100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111110", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 2, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01", + "0101", + "010100", + "01010001", + "0101000111", + "010100011100", + "01010001110011", + "0101000111001101", + "010100011100110101", + "01010001110011010111", + "0101000111001101011100", + "010100011100110101110001", + "01010001110011010111000100", + "0101000111001101011100010010", + "010100011100110101110001001001", + "01010001110011010111000100100110", + "0101000111001101011100010010011001", + "010100011100110101110001001001100100", + "01010001110011010111000100100110010010", + "0101000111001101011100010010011001001010", + "010100011100110101110001001001100100101000", + "01010001110011010111000100100110010010100001", + "0101000111001101011100010010011001001010000111", + "010100011100110101110001001001100100101000011100", + "01010001110011010111000100100110010010100001110000", + "0101000111001101011100010010011001001010000111000011", + "010100011100110101110001001001100100101000011100001110", + "01010001110011010111000100100110010010100001110000111010", + "0101000111001101011100010010011001001010000111000011101011", + "010100011100110101110001001001100100101000011100001110101100", + "01010001110011010111000100100110010010100001110000111010110001", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100", + "01010001110011010111000100100110010010100001110000111010110001010000", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "01010001110011010111000100100110010010100001110000111010110001010000101110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 3, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "010", + "010100", + "010100011", + "010100011100", + "010100011100110", + "010100011100110101", + "010100011100110101110", + "010100011100110101110001", + "010100011100110101110001001", + "010100011100110101110001001001", + "010100011100110101110001001001100", + "010100011100110101110001001001100100", + "010100011100110101110001001001100100101", + "010100011100110101110001001001100100101000", + "010100011100110101110001001001100100101000011", + "010100011100110101110001001001100100101000011100", + "010100011100110101110001001001100100101000011100001", + "010100011100110101110001001001100100101000011100001110", + "010100011100110101110001001001100100101000011100001110101", + "010100011100110101110001001001100100101000011100001110101100", + "010100011100110101110001001001100100101000011100001110101100010", + "010100011100110101110001001001100100101000011100001110101100010100", + "010100011100110101110001001001100100101000011100001110101100010100001", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "010100011100110101110001001001100100101000011100001110101100010100001011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 4, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101", + "01010001", + "010100011100", + "0101000111001101", + "01010001110011010111", + "010100011100110101110001", + "0101000111001101011100010010", + "01010001110011010111000100100110", + "010100011100110101110001001001100100", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100001", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000011", + "01010001110011010111000100100110010010100001110000111010", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010000", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 8, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001", + "0101000111001101", + "010100011100110101110001", + "01010001110011010111000100100110", + "0101000111001101011100010010011001001010", + "010100011100110101110001001001100100101000011100", + "01010001110011010111000100100110010010100001110000111010", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 10, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111", + "01010001110011010111", + "010100011100110101110001001001", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100001110000", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 11, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001110", + "0101000111001101011100", + "010100011100110101110001001001100", + "01010001110011010111000100100110010010100001", + "0101000111001101011100010010011001001010000111000011101", + "010100011100110101110001001001100100101000011100001110101100010100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 16, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111001101", + "01010001110011010111000100100110", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 31, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111001101011100010010011", + "01010001110011010111000100100110010010100001110000111010110001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 32, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001110011010111000100100110", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 1, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0", + "01", + "010", + "0101", + "01010", + "010100", + "0101000", + "01010001", + "010100011", + "0101000111", + "01010001110", + "010100011100", + "0101000111001", + "01010001110011", + "010100011100110", + "0101000111001101", + "01010001110011010", + "010100011100110101", + "0101000111001101011", + "01010001110011010111", + "010100011100110101110", + "0101000111001101011100", + "01010001110011010111000", + "010100011100110101110001", + "0101000111001101011100010", + "01010001110011010111000100", + "010100011100110101110001001", + "0101000111001101011100010010", + "01010001110011010111000100100", + "010100011100110101110001001001", + "0101000111001101011100010010011", + "01010001110011010111000100100110", + "010100011100110101110001001001100", + "0101000111001101011100010010011001", + "01010001110011010111000100100110010", + "010100011100110101110001001001100100", + "0101000111001101011100010010011001001", + "01010001110011010111000100100110010010", + "010100011100110101110001001001100100101", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100", + "010100011100110101110001001001100100101000", + "0101000111001101011100010010011001001010000", + "01010001110011010111000100100110010010100001", + "010100011100110101110001001001100100101000011", + "0101000111001101011100010010011001001010000111", + "01010001110011010111000100100110010010100001110", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000", + "01010001110011010111000100100110010010100001110000", + "010100011100110101110001001001100100101000011100001", + "0101000111001101011100010010011001001010000111000011", + "01010001110011010111000100100110010010100001110000111", + "010100011100110101110001001001100100101000011100001110", + "0101000111001101011100010010011001001010000111000011101", + "01010001110011010111000100100110010010100001110000111010", + "010100011100110101110001001001100100101000011100001110101", + "0101000111001101011100010010011001001010000111000011101011", + "01010001110011010111000100100110010010100001110000111010110", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000", + "01010001110011010111000100100110010010100001110000111010110001", + "010100011100110101110001001001100100101000011100001110101100010", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010", + "010100011100110101110001001001100100101000011100001110101100010100", + "0101000111001101011100010010011001001010000111000011101011000101000", + "01010001110011010111000100100110010010100001110000111010110001010000", + "010100011100110101110001001001100100101000011100001110101100010100001", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "01010001110011010111000100100110010010100001110000111010110001010000101", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "0101000111001101011100010010011001001010000111000011101011000101000010111", + "01010001110011010111000100100110010010100001110000111010110001010000101110", + "010100011100110101110001001001100100101000011100001110101100010100001011100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111110", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 2, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01", + "0101", + "010100", + "01010001", + "0101000111", + "010100011100", + "01010001110011", + "0101000111001101", + "010100011100110101", + "01010001110011010111", + "0101000111001101011100", + "010100011100110101110001", + "01010001110011010111000100", + "0101000111001101011100010010", + "010100011100110101110001001001", + "01010001110011010111000100100110", + "0101000111001101011100010010011001", + "010100011100110101110001001001100100", + "01010001110011010111000100100110010010", + "0101000111001101011100010010011001001010", + "010100011100110101110001001001100100101000", + "01010001110011010111000100100110010010100001", + "0101000111001101011100010010011001001010000111", + "010100011100110101110001001001100100101000011100", + "01010001110011010111000100100110010010100001110000", + "0101000111001101011100010010011001001010000111000011", + "010100011100110101110001001001100100101000011100001110", + "01010001110011010111000100100110010010100001110000111010", + "0101000111001101011100010010011001001010000111000011101011", + "010100011100110101110001001001100100101000011100001110101100", + "01010001110011010111000100100110010010100001110000111010110001", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100", + "01010001110011010111000100100110010010100001110000111010110001010000", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "01010001110011010111000100100110010010100001110000111010110001010000101110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 3, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "010", + "010100", + "010100011", + "010100011100", + "010100011100110", + "010100011100110101", + "010100011100110101110", + "010100011100110101110001", + "010100011100110101110001001", + "010100011100110101110001001001", + "010100011100110101110001001001100", + "010100011100110101110001001001100100", + "010100011100110101110001001001100100101", + "010100011100110101110001001001100100101000", + "010100011100110101110001001001100100101000011", + "010100011100110101110001001001100100101000011100", + "010100011100110101110001001001100100101000011100001", + "010100011100110101110001001001100100101000011100001110", + "010100011100110101110001001001100100101000011100001110101", + "010100011100110101110001001001100100101000011100001110101100", + "010100011100110101110001001001100100101000011100001110101100010", + "010100011100110101110001001001100100101000011100001110101100010100", + "010100011100110101110001001001100100101000011100001110101100010100001", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "010100011100110101110001001001100100101000011100001110101100010100001011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 4, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101", + "01010001", + "010100011100", + "0101000111001101", + "01010001110011010111", + "010100011100110101110001", + "0101000111001101011100010010", + "01010001110011010111000100100110", + "010100011100110101110001001001100100", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100001", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000011", + "01010001110011010111000100100110010010100001110000111010", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010000", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 8, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001", + "0101000111001101", + "010100011100110101110001", + "01010001110011010111000100100110", + "0101000111001101011100010010011001001010", + "010100011100110101110001001001100100101000011100", + "01010001110011010111000100100110010010100001110000111010", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 10, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111", + "01010001110011010111", + "010100011100110101110001001001", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100001110000", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 11, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001110", + "0101000111001101011100", + "010100011100110101110001001001100", + "01010001110011010111000100100110010010100001", + "0101000111001101011100010010011001001010000111000011101", + "010100011100110101110001001001100100101000011100001110101100010100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 16, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111001101", + "01010001110011010111000100100110", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 31, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111001101011100010010011", + "01010001110011010111000100100110010010100001110000111010110001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 32, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001110011010111000100100110", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 1, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0", + "01", + "010", + "0101", + "01010", + "010100", + "0101000", + "01010001", + "010100011", + "0101000111", + "01010001110", + "010100011100", + "0101000111001", + "01010001110011", + "010100011100110", + "0101000111001101", + "01010001110011010", + "010100011100110101", + "0101000111001101011", + "01010001110011010111", + "010100011100110101110", + "0101000111001101011100", + "01010001110011010111000", + "010100011100110101110001", + "0101000111001101011100010", + "01010001110011010111000100", + "010100011100110101110001001", + "0101000111001101011100010010", + "01010001110011010111000100100", + "010100011100110101110001001001", + "0101000111001101011100010010011", + "01010001110011010111000100100110", + "010100011100110101110001001001100", + "0101000111001101011100010010011001", + "01010001110011010111000100100110010", + "010100011100110101110001001001100100", + "0101000111001101011100010010011001001", + "01010001110011010111000100100110010010", + "010100011100110101110001001001100100101", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100", + "010100011100110101110001001001100100101000", + "0101000111001101011100010010011001001010000", + "01010001110011010111000100100110010010100001", + "010100011100110101110001001001100100101000011", + "0101000111001101011100010010011001001010000111", + "01010001110011010111000100100110010010100001110", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000", + "01010001110011010111000100100110010010100001110000", + "010100011100110101110001001001100100101000011100001", + "0101000111001101011100010010011001001010000111000011", + "01010001110011010111000100100110010010100001110000111", + "010100011100110101110001001001100100101000011100001110", + "0101000111001101011100010010011001001010000111000011101", + "01010001110011010111000100100110010010100001110000111010", + "010100011100110101110001001001100100101000011100001110101", + "0101000111001101011100010010011001001010000111000011101011", + "01010001110011010111000100100110010010100001110000111010110", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000", + "01010001110011010111000100100110010010100001110000111010110001", + "010100011100110101110001001001100100101000011100001110101100010", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010", + "010100011100110101110001001001100100101000011100001110101100010100", + "0101000111001101011100010010011001001010000111000011101011000101000", + "01010001110011010111000100100110010010100001110000111010110001010000", + "010100011100110101110001001001100100101000011100001110101100010100001", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "01010001110011010111000100100110010010100001110000111010110001010000101", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "0101000111001101011100010010011001001010000111000011101011000101000010111", + "01010001110011010111000100100110010010100001110000111010110001010000101110", + "010100011100110101110001001001100100101000011100001110101100010100001011100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111110", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 2, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01", + "0101", + "010100", + "01010001", + "0101000111", + "010100011100", + "01010001110011", + "0101000111001101", + "010100011100110101", + "01010001110011010111", + "0101000111001101011100", + "010100011100110101110001", + "01010001110011010111000100", + "0101000111001101011100010010", + "010100011100110101110001001001", + "01010001110011010111000100100110", + "0101000111001101011100010010011001", + "010100011100110101110001001001100100", + "01010001110011010111000100100110010010", + "0101000111001101011100010010011001001010", + "010100011100110101110001001001100100101000", + "01010001110011010111000100100110010010100001", + "0101000111001101011100010010011001001010000111", + "010100011100110101110001001001100100101000011100", + "01010001110011010111000100100110010010100001110000", + "0101000111001101011100010010011001001010000111000011", + "010100011100110101110001001001100100101000011100001110", + "01010001110011010111000100100110010010100001110000111010", + "0101000111001101011100010010011001001010000111000011101011", + "010100011100110101110001001001100100101000011100001110101100", + "01010001110011010111000100100110010010100001110000111010110001", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100", + "01010001110011010111000100100110010010100001110000111010110001010000", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "01010001110011010111000100100110010010100001110000111010110001010000101110", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 3, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "010", + "010100", + "010100011", + "010100011100", + "010100011100110", + "010100011100110101", + "010100011100110101110", + "010100011100110101110001", + "010100011100110101110001001", + "010100011100110101110001001001", + "010100011100110101110001001001100", + "010100011100110101110001001001100100", + "010100011100110101110001001001100100101", + "010100011100110101110001001001100100101000", + "010100011100110101110001001001100100101000011", + "010100011100110101110001001001100100101000011100", + "010100011100110101110001001001100100101000011100001", + "010100011100110101110001001001100100101000011100001110", + "010100011100110101110001001001100100101000011100001110101", + "010100011100110101110001001001100100101000011100001110101100", + "010100011100110101110001001001100100101000011100001110101100010", + "010100011100110101110001001001100100101000011100001110101100010100", + "010100011100110101110001001001100100101000011100001110101100010100001", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "010100011100110101110001001001100100101000011100001110101100010100001011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 4, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101", + "01010001", + "010100011100", + "0101000111001101", + "01010001110011010111", + "010100011100110101110001", + "0101000111001101011100010010", + "01010001110011010111000100100110", + "010100011100110101110001001001100100", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100001", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000011", + "01010001110011010111000100100110010010100001110000111010", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010000", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 8, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001", + "0101000111001101", + "010100011100110101110001", + "01010001110011010111000100100110", + "0101000111001101011100010010011001001010", + "010100011100110101110001001001100100101000011100", + "01010001110011010111000100100110010010100001110000111010", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100001011", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 10, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111", + "01010001110011010111", + "010100011100110101110001001001", + "0101000111001101011100010010011001001010", + "01010001110011010111000100100110010010100001110000", + "010100011100110101110001001001100100101000011100001110101100", + "0101000111001101011100010010011001001010000111000011101011000101000010", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000000000000000000010111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 11, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001110", + "0101000111001101011100", + "010100011100110101110001001001100", + "01010001110011010111000100100110010010100001", + "0101000111001101011100010010011001001010000111000011101", + "010100011100110101110001001001100100101000011100001110101100010100", + "01010001110011010111000100100110010010100001110000111010110001010000101110010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010000", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 16, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111001101", + "01010001110011010111000100100110", + "010100011100110101110001001001100100101000011100", + "0101000111001101011100010010011001001010000111000011101011000101", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 31, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "0101000111001101011100010010011", + "01010001110011010111000100100110010010100001110000111010110001", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001", + "0101000111001101011100010010011001001010000111000011101011000101000010111001001101011100010010100000000000000000000101111111", + }, +}, +{ + .value = mc_dec128_from_string("-0.00700000000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 32, + .expectEdges = { + "root", + "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100", + "01010001110011010111000100100110", + "0101000111001101011100010010011001001010000111000011101011000101", + "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 1, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1", + "10", + "101", + "1010", + "10101", + "101011", + "1010111", + "10101110", + "101011100", + "1010111000", + "10101110001", + "101011100011", + "1010111000111", + "10101110001110", + "101011100011100", + "1010111000111001", + "10101110001110011", + "101011100011100110", + "1010111000111001100", + "10101110001110011000", + "101011100011100110001", + "1010111000111001100010", + "10101110001110011000101", + "101011100011100110001011", + "1010111000111001100010110", + "10101110001110011000101101", + "101011100011100110001011011", + "1010111000111001100010110111", + "10101110001110011000101101111", + "101011100011100110001011011110", + "1010111000111001100010110111101", + "10101110001110011000101101111010", + "101011100011100110001011011110101", + "1010111000111001100010110111101010", + "10101110001110011000101101111010101", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101", + "10101110001110011000101101111010101010", + "101011100011100110001011011110101010100", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001", + "101011100011100110001011011110101010100010", + "1010111000111001100010110111101010101000100", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011", + "1010111000111001100010110111101010101000100111", + "10101110001110011000101101111010101010001001111", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001", + "101011100011100110001011011110101010100010011111110010", + "1010111000111001100010110111101010101000100111111100100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010", + "1010111000111001100010110111101010101000100111111100100100", + "10101110001110011000101101111010101010001001111111001001000", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000", + "101011100011100110001011011110101010100010011111110010010001000000", + "1010111000111001100010110111101010101000100111111100100100010000001", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 2, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10", + "1010", + "101011", + "10101110", + "1010111000", + "101011100011", + "10101110001110", + "1010111000111001", + "101011100011100110", + "10101110001110011000", + "1010111000111001100010", + "101011100011100110001011", + "10101110001110011000101101", + "1010111000111001100010110111", + "101011100011100110001011011110", + "10101110001110011000101101111010", + "1010111000111001100010110111101010", + "101011100011100110001011011110101010", + "10101110001110011000101101111010101010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111", + "1010111000111001100010110111101010101000100111111100", + "101011100011100110001011011110101010100010011111110010", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100", + "101011100011100110001011011110101010100010011111110010010001", + "10101110001110011000101101111010101010001001111111001001000100", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 3, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "101", + "101011", + "101011100", + "101011100011", + "101011100011100", + "101011100011100110", + "101011100011100110001", + "101011100011100110001011", + "101011100011100110001011011", + "101011100011100110001011011110", + "101011100011100110001011011110101", + "101011100011100110001011011110101010", + "101011100011100110001011011110101010100", + "101011100011100110001011011110101010100010", + "101011100011100110001011011110101010100010011", + "101011100011100110001011011110101010100010011111", + "101011100011100110001011011110101010100010011111110", + "101011100011100110001011011110101010100010011111110010", + "101011100011100110001011011110101010100010011111110010010", + "101011100011100110001011011110101010100010011111110010010001", + "101011100011100110001011011110101010100010011111110010010001000", + "101011100011100110001011011110101010100010011111110010010001000000", + "101011100011100110001011011110101010100010011111110010010001000000101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 4, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010", + "10101110", + "101011100011", + "1010111000111001", + "10101110001110011000", + "101011100011100110001011", + "1010111000111001100010110111", + "10101110001110011000101101111010", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 8, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110", + "1010111000111001", + "101011100011100110001011", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 10, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000", + "10101110001110011000", + "101011100011100110001011011110", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 11, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001", + "1010111000111001100010", + "101011100011100110001011011110101", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111111100100", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 16, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001", + "10101110001110011000101101111010", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 31, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001100010110111101", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 32, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 1, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1", + "10", + "101", + "1010", + "10101", + "101011", + "1010111", + "10101110", + "101011100", + "1010111000", + "10101110001", + "101011100011", + "1010111000111", + "10101110001110", + "101011100011100", + "1010111000111001", + "10101110001110011", + "101011100011100110", + "1010111000111001100", + "10101110001110011000", + "101011100011100110001", + "1010111000111001100010", + "10101110001110011000101", + "101011100011100110001011", + "1010111000111001100010110", + "10101110001110011000101101", + "101011100011100110001011011", + "1010111000111001100010110111", + "10101110001110011000101101111", + "101011100011100110001011011110", + "1010111000111001100010110111101", + "10101110001110011000101101111010", + "101011100011100110001011011110101", + "1010111000111001100010110111101010", + "10101110001110011000101101111010101", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101", + "10101110001110011000101101111010101010", + "101011100011100110001011011110101010100", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001", + "101011100011100110001011011110101010100010", + "1010111000111001100010110111101010101000100", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011", + "1010111000111001100010110111101010101000100111", + "10101110001110011000101101111010101010001001111", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001", + "101011100011100110001011011110101010100010011111110010", + "1010111000111001100010110111101010101000100111111100100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010", + "1010111000111001100010110111101010101000100111111100100100", + "10101110001110011000101101111010101010001001111111001001000", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000", + "101011100011100110001011011110101010100010011111110010010001000000", + "1010111000111001100010110111101010101000100111111100100100010000001", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 2, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10", + "1010", + "101011", + "10101110", + "1010111000", + "101011100011", + "10101110001110", + "1010111000111001", + "101011100011100110", + "10101110001110011000", + "1010111000111001100010", + "101011100011100110001011", + "10101110001110011000101101", + "1010111000111001100010110111", + "101011100011100110001011011110", + "10101110001110011000101101111010", + "1010111000111001100010110111101010", + "101011100011100110001011011110101010", + "10101110001110011000101101111010101010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111", + "1010111000111001100010110111101010101000100111111100", + "101011100011100110001011011110101010100010011111110010", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100", + "101011100011100110001011011110101010100010011111110010010001", + "10101110001110011000101101111010101010001001111111001001000100", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 3, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "101", + "101011", + "101011100", + "101011100011", + "101011100011100", + "101011100011100110", + "101011100011100110001", + "101011100011100110001011", + "101011100011100110001011011", + "101011100011100110001011011110", + "101011100011100110001011011110101", + "101011100011100110001011011110101010", + "101011100011100110001011011110101010100", + "101011100011100110001011011110101010100010", + "101011100011100110001011011110101010100010011", + "101011100011100110001011011110101010100010011111", + "101011100011100110001011011110101010100010011111110", + "101011100011100110001011011110101010100010011111110010", + "101011100011100110001011011110101010100010011111110010010", + "101011100011100110001011011110101010100010011111110010010001", + "101011100011100110001011011110101010100010011111110010010001000", + "101011100011100110001011011110101010100010011111110010010001000000", + "101011100011100110001011011110101010100010011111110010010001000000101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 4, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010", + "10101110", + "101011100011", + "1010111000111001", + "10101110001110011000", + "101011100011100110001011", + "1010111000111001100010110111", + "10101110001110011000101101111010", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 8, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110", + "1010111000111001", + "101011100011100110001011", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 10, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000", + "10101110001110011000", + "101011100011100110001011011110", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 11, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001", + "1010111000111001100010", + "101011100011100110001011011110101", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111111100100", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 16, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001", + "10101110001110011000101101111010", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 31, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001100010110111101", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 32, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 1, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1", + "10", + "101", + "1010", + "10101", + "101011", + "1010111", + "10101110", + "101011100", + "1010111000", + "10101110001", + "101011100011", + "1010111000111", + "10101110001110", + "101011100011100", + "1010111000111001", + "10101110001110011", + "101011100011100110", + "1010111000111001100", + "10101110001110011000", + "101011100011100110001", + "1010111000111001100010", + "10101110001110011000101", + "101011100011100110001011", + "1010111000111001100010110", + "10101110001110011000101101", + "101011100011100110001011011", + "1010111000111001100010110111", + "10101110001110011000101101111", + "101011100011100110001011011110", + "1010111000111001100010110111101", + "10101110001110011000101101111010", + "101011100011100110001011011110101", + "1010111000111001100010110111101010", + "10101110001110011000101101111010101", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101", + "10101110001110011000101101111010101010", + "101011100011100110001011011110101010100", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001", + "101011100011100110001011011110101010100010", + "1010111000111001100010110111101010101000100", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011", + "1010111000111001100010110111101010101000100111", + "10101110001110011000101101111010101010001001111", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001", + "101011100011100110001011011110101010100010011111110010", + "1010111000111001100010110111101010101000100111111100100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010", + "1010111000111001100010110111101010101000100111111100100100", + "10101110001110011000101101111010101010001001111111001001000", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000", + "101011100011100110001011011110101010100010011111110010010001000000", + "1010111000111001100010110111101010101000100111111100100100010000001", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 2, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10", + "1010", + "101011", + "10101110", + "1010111000", + "101011100011", + "10101110001110", + "1010111000111001", + "101011100011100110", + "10101110001110011000", + "1010111000111001100010", + "101011100011100110001011", + "10101110001110011000101101", + "1010111000111001100010110111", + "101011100011100110001011011110", + "10101110001110011000101101111010", + "1010111000111001100010110111101010", + "101011100011100110001011011110101010", + "10101110001110011000101101111010101010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111", + "1010111000111001100010110111101010101000100111111100", + "101011100011100110001011011110101010100010011111110010", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100", + "101011100011100110001011011110101010100010011111110010010001", + "10101110001110011000101101111010101010001001111111001001000100", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 3, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "101", + "101011", + "101011100", + "101011100011", + "101011100011100", + "101011100011100110", + "101011100011100110001", + "101011100011100110001011", + "101011100011100110001011011", + "101011100011100110001011011110", + "101011100011100110001011011110101", + "101011100011100110001011011110101010", + "101011100011100110001011011110101010100", + "101011100011100110001011011110101010100010", + "101011100011100110001011011110101010100010011", + "101011100011100110001011011110101010100010011111", + "101011100011100110001011011110101010100010011111110", + "101011100011100110001011011110101010100010011111110010", + "101011100011100110001011011110101010100010011111110010010", + "101011100011100110001011011110101010100010011111110010010001", + "101011100011100110001011011110101010100010011111110010010001000", + "101011100011100110001011011110101010100010011111110010010001000000", + "101011100011100110001011011110101010100010011111110010010001000000101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 4, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010", + "10101110", + "101011100011", + "1010111000111001", + "10101110001110011000", + "101011100011100110001011", + "1010111000111001100010110111", + "10101110001110011000101101111010", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 8, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110", + "1010111000111001", + "101011100011100110001011", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 10, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000", + "10101110001110011000", + "101011100011100110001011011110", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 11, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001", + "1010111000111001100010", + "101011100011100110001011011110101", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111111100100", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 16, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001", + "10101110001110011000101101111010", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 31, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001100010110111101", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 32, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 1, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1", + "10", + "101", + "1010", + "10101", + "101011", + "1010111", + "10101110", + "101011100", + "1010111000", + "10101110001", + "101011100011", + "1010111000111", + "10101110001110", + "101011100011100", + "1010111000111001", + "10101110001110011", + "101011100011100110", + "1010111000111001100", + "10101110001110011000", + "101011100011100110001", + "1010111000111001100010", + "10101110001110011000101", + "101011100011100110001011", + "1010111000111001100010110", + "10101110001110011000101101", + "101011100011100110001011011", + "1010111000111001100010110111", + "10101110001110011000101101111", + "101011100011100110001011011110", + "1010111000111001100010110111101", + "10101110001110011000101101111010", + "101011100011100110001011011110101", + "1010111000111001100010110111101010", + "10101110001110011000101101111010101", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101", + "10101110001110011000101101111010101010", + "101011100011100110001011011110101010100", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001", + "101011100011100110001011011110101010100010", + "1010111000111001100010110111101010101000100", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011", + "1010111000111001100010110111101010101000100111", + "10101110001110011000101101111010101010001001111", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001", + "101011100011100110001011011110101010100010011111110010", + "1010111000111001100010110111101010101000100111111100100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010", + "1010111000111001100010110111101010101000100111111100100100", + "10101110001110011000101101111010101010001001111111001001000", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000", + "101011100011100110001011011110101010100010011111110010010001000000", + "1010111000111001100010110111101010101000100111111100100100010000001", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 2, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10", + "1010", + "101011", + "10101110", + "1010111000", + "101011100011", + "10101110001110", + "1010111000111001", + "101011100011100110", + "10101110001110011000", + "1010111000111001100010", + "101011100011100110001011", + "10101110001110011000101101", + "1010111000111001100010110111", + "101011100011100110001011011110", + "10101110001110011000101101111010", + "1010111000111001100010110111101010", + "101011100011100110001011011110101010", + "10101110001110011000101101111010101010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111", + "1010111000111001100010110111101010101000100111111100", + "101011100011100110001011011110101010100010011111110010", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100", + "101011100011100110001011011110101010100010011111110010010001", + "10101110001110011000101101111010101010001001111111001001000100", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 3, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "101", + "101011", + "101011100", + "101011100011", + "101011100011100", + "101011100011100110", + "101011100011100110001", + "101011100011100110001011", + "101011100011100110001011011", + "101011100011100110001011011110", + "101011100011100110001011011110101", + "101011100011100110001011011110101010", + "101011100011100110001011011110101010100", + "101011100011100110001011011110101010100010", + "101011100011100110001011011110101010100010011", + "101011100011100110001011011110101010100010011111", + "101011100011100110001011011110101010100010011111110", + "101011100011100110001011011110101010100010011111110010", + "101011100011100110001011011110101010100010011111110010010", + "101011100011100110001011011110101010100010011111110010010001", + "101011100011100110001011011110101010100010011111110010010001000", + "101011100011100110001011011110101010100010011111110010010001000000", + "101011100011100110001011011110101010100010011111110010010001000000101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 4, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010", + "10101110", + "101011100011", + "1010111000111001", + "10101110001110011000", + "101011100011100110001011", + "1010111000111001100010110111", + "10101110001110011000101101111010", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 8, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110", + "1010111000111001", + "101011100011100110001011", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 10, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000", + "10101110001110011000", + "101011100011100110001011011110", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 11, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001", + "1010111000111001100010", + "101011100011100110001011011110101", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111111100100", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 16, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001", + "10101110001110011000101101111010", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 31, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001100010110111101", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 32, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 1, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1", + "10", + "101", + "1010", + "10101", + "101011", + "1010111", + "10101110", + "101011100", + "1010111000", + "10101110001", + "101011100011", + "1010111000111", + "10101110001110", + "101011100011100", + "1010111000111001", + "10101110001110011", + "101011100011100110", + "1010111000111001100", + "10101110001110011000", + "101011100011100110001", + "1010111000111001100010", + "10101110001110011000101", + "101011100011100110001011", + "1010111000111001100010110", + "10101110001110011000101101", + "101011100011100110001011011", + "1010111000111001100010110111", + "10101110001110011000101101111", + "101011100011100110001011011110", + "1010111000111001100010110111101", + "10101110001110011000101101111010", + "101011100011100110001011011110101", + "1010111000111001100010110111101010", + "10101110001110011000101101111010101", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101", + "10101110001110011000101101111010101010", + "101011100011100110001011011110101010100", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001", + "101011100011100110001011011110101010100010", + "1010111000111001100010110111101010101000100", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011", + "1010111000111001100010110111101010101000100111", + "10101110001110011000101101111010101010001001111", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001", + "101011100011100110001011011110101010100010011111110010", + "1010111000111001100010110111101010101000100111111100100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010", + "1010111000111001100010110111101010101000100111111100100100", + "10101110001110011000101101111010101010001001111111001001000", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000", + "101011100011100110001011011110101010100010011111110010010001000000", + "1010111000111001100010110111101010101000100111111100100100010000001", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 2, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10", + "1010", + "101011", + "10101110", + "1010111000", + "101011100011", + "10101110001110", + "1010111000111001", + "101011100011100110", + "10101110001110011000", + "1010111000111001100010", + "101011100011100110001011", + "10101110001110011000101101", + "1010111000111001100010110111", + "101011100011100110001011011110", + "10101110001110011000101101111010", + "1010111000111001100010110111101010", + "101011100011100110001011011110101010", + "10101110001110011000101101111010101010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111", + "1010111000111001100010110111101010101000100111111100", + "101011100011100110001011011110101010100010011111110010", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100", + "101011100011100110001011011110101010100010011111110010010001", + "10101110001110011000101101111010101010001001111111001001000100", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 3, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "101", + "101011", + "101011100", + "101011100011", + "101011100011100", + "101011100011100110", + "101011100011100110001", + "101011100011100110001011", + "101011100011100110001011011", + "101011100011100110001011011110", + "101011100011100110001011011110101", + "101011100011100110001011011110101010", + "101011100011100110001011011110101010100", + "101011100011100110001011011110101010100010", + "101011100011100110001011011110101010100010011", + "101011100011100110001011011110101010100010011111", + "101011100011100110001011011110101010100010011111110", + "101011100011100110001011011110101010100010011111110010", + "101011100011100110001011011110101010100010011111110010010", + "101011100011100110001011011110101010100010011111110010010001", + "101011100011100110001011011110101010100010011111110010010001000", + "101011100011100110001011011110101010100010011111110010010001000000", + "101011100011100110001011011110101010100010011111110010010001000000101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 4, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010", + "10101110", + "101011100011", + "1010111000111001", + "10101110001110011000", + "101011100011100110001011", + "1010111000111001100010110111", + "10101110001110011000101101111010", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 8, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110", + "1010111000111001", + "101011100011100110001011", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 10, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000", + "10101110001110011000", + "101011100011100110001011011110", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 11, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001", + "1010111000111001100010", + "101011100011100110001011011110101", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111111100100", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 16, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001", + "10101110001110011000101101111010", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 31, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001100010110111101", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 32, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 1, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1", + "10", + "101", + "1010", + "10101", + "101011", + "1010111", + "10101110", + "101011100", + "1010111000", + "10101110001", + "101011100011", + "1010111000111", + "10101110001110", + "101011100011100", + "1010111000111001", + "10101110001110011", + "101011100011100110", + "1010111000111001100", + "10101110001110011000", + "101011100011100110001", + "1010111000111001100010", + "10101110001110011000101", + "101011100011100110001011", + "1010111000111001100010110", + "10101110001110011000101101", + "101011100011100110001011011", + "1010111000111001100010110111", + "10101110001110011000101101111", + "101011100011100110001011011110", + "1010111000111001100010110111101", + "10101110001110011000101101111010", + "101011100011100110001011011110101", + "1010111000111001100010110111101010", + "10101110001110011000101101111010101", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101", + "10101110001110011000101101111010101010", + "101011100011100110001011011110101010100", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001", + "101011100011100110001011011110101010100010", + "1010111000111001100010110111101010101000100", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011", + "1010111000111001100010110111101010101000100111", + "10101110001110011000101101111010101010001001111", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001", + "101011100011100110001011011110101010100010011111110010", + "1010111000111001100010110111101010101000100111111100100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010", + "1010111000111001100010110111101010101000100111111100100100", + "10101110001110011000101101111010101010001001111111001001000", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000", + "101011100011100110001011011110101010100010011111110010010001000000", + "1010111000111001100010110111101010101000100111111100100100010000001", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 2, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10", + "1010", + "101011", + "10101110", + "1010111000", + "101011100011", + "10101110001110", + "1010111000111001", + "101011100011100110", + "10101110001110011000", + "1010111000111001100010", + "101011100011100110001011", + "10101110001110011000101101", + "1010111000111001100010110111", + "101011100011100110001011011110", + "10101110001110011000101101111010", + "1010111000111001100010110111101010", + "101011100011100110001011011110101010", + "10101110001110011000101101111010101010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111", + "1010111000111001100010110111101010101000100111111100", + "101011100011100110001011011110101010100010011111110010", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100", + "101011100011100110001011011110101010100010011111110010010001", + "10101110001110011000101101111010101010001001111111001001000100", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 3, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "101", + "101011", + "101011100", + "101011100011", + "101011100011100", + "101011100011100110", + "101011100011100110001", + "101011100011100110001011", + "101011100011100110001011011", + "101011100011100110001011011110", + "101011100011100110001011011110101", + "101011100011100110001011011110101010", + "101011100011100110001011011110101010100", + "101011100011100110001011011110101010100010", + "101011100011100110001011011110101010100010011", + "101011100011100110001011011110101010100010011111", + "101011100011100110001011011110101010100010011111110", + "101011100011100110001011011110101010100010011111110010", + "101011100011100110001011011110101010100010011111110010010", + "101011100011100110001011011110101010100010011111110010010001", + "101011100011100110001011011110101010100010011111110010010001000", + "101011100011100110001011011110101010100010011111110010010001000000", + "101011100011100110001011011110101010100010011111110010010001000000101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 4, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010", + "10101110", + "101011100011", + "1010111000111001", + "10101110001110011000", + "101011100011100110001011", + "1010111000111001100010110111", + "10101110001110011000101101111010", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 8, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110", + "1010111000111001", + "101011100011100110001011", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 10, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000", + "10101110001110011000", + "101011100011100110001011011110", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 11, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001", + "1010111000111001100010", + "101011100011100110001011011110101", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111111100100", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 16, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001", + "10101110001110011000101101111010", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 31, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001100010110111101", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 32, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 1, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1", + "10", + "101", + "1010", + "10101", + "101011", + "1010111", + "10101110", + "101011100", + "1010111000", + "10101110001", + "101011100011", + "1010111000111", + "10101110001110", + "101011100011100", + "1010111000111001", + "10101110001110011", + "101011100011100110", + "1010111000111001100", + "10101110001110011000", + "101011100011100110001", + "1010111000111001100010", + "10101110001110011000101", + "101011100011100110001011", + "1010111000111001100010110", + "10101110001110011000101101", + "101011100011100110001011011", + "1010111000111001100010110111", + "10101110001110011000101101111", + "101011100011100110001011011110", + "1010111000111001100010110111101", + "10101110001110011000101101111010", + "101011100011100110001011011110101", + "1010111000111001100010110111101010", + "10101110001110011000101101111010101", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101", + "10101110001110011000101101111010101010", + "101011100011100110001011011110101010100", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001", + "101011100011100110001011011110101010100010", + "1010111000111001100010110111101010101000100", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011", + "1010111000111001100010110111101010101000100111", + "10101110001110011000101101111010101010001001111", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001", + "101011100011100110001011011110101010100010011111110010", + "1010111000111001100010110111101010101000100111111100100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010", + "1010111000111001100010110111101010101000100111111100100100", + "10101110001110011000101101111010101010001001111111001001000", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000", + "101011100011100110001011011110101010100010011111110010010001000000", + "1010111000111001100010110111101010101000100111111100100100010000001", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 2, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10", + "1010", + "101011", + "10101110", + "1010111000", + "101011100011", + "10101110001110", + "1010111000111001", + "101011100011100110", + "10101110001110011000", + "1010111000111001100010", + "101011100011100110001011", + "10101110001110011000101101", + "1010111000111001100010110111", + "101011100011100110001011011110", + "10101110001110011000101101111010", + "1010111000111001100010110111101010", + "101011100011100110001011011110101010", + "10101110001110011000101101111010101010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111", + "1010111000111001100010110111101010101000100111111100", + "101011100011100110001011011110101010100010011111110010", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100", + "101011100011100110001011011110101010100010011111110010010001", + "10101110001110011000101101111010101010001001111111001001000100", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 3, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "101", + "101011", + "101011100", + "101011100011", + "101011100011100", + "101011100011100110", + "101011100011100110001", + "101011100011100110001011", + "101011100011100110001011011", + "101011100011100110001011011110", + "101011100011100110001011011110101", + "101011100011100110001011011110101010", + "101011100011100110001011011110101010100", + "101011100011100110001011011110101010100010", + "101011100011100110001011011110101010100010011", + "101011100011100110001011011110101010100010011111", + "101011100011100110001011011110101010100010011111110", + "101011100011100110001011011110101010100010011111110010", + "101011100011100110001011011110101010100010011111110010010", + "101011100011100110001011011110101010100010011111110010010001", + "101011100011100110001011011110101010100010011111110010010001000", + "101011100011100110001011011110101010100010011111110010010001000000", + "101011100011100110001011011110101010100010011111110010010001000000101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 4, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010", + "10101110", + "101011100011", + "1010111000111001", + "10101110001110011000", + "101011100011100110001011", + "1010111000111001100010110111", + "10101110001110011000101101111010", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 8, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110", + "1010111000111001", + "101011100011100110001011", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 10, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000", + "10101110001110011000", + "101011100011100110001011011110", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 11, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001", + "1010111000111001100010", + "101011100011100110001011011110101", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111111100100", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 16, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001", + "10101110001110011000101101111010", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 31, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001100010110111101", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 32, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 1, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1", + "10", + "101", + "1010", + "10101", + "101011", + "1010111", + "10101110", + "101011100", + "1010111000", + "10101110001", + "101011100011", + "1010111000111", + "10101110001110", + "101011100011100", + "1010111000111001", + "10101110001110011", + "101011100011100110", + "1010111000111001100", + "10101110001110011000", + "101011100011100110001", + "1010111000111001100010", + "10101110001110011000101", + "101011100011100110001011", + "1010111000111001100010110", + "10101110001110011000101101", + "101011100011100110001011011", + "1010111000111001100010110111", + "10101110001110011000101101111", + "101011100011100110001011011110", + "1010111000111001100010110111101", + "10101110001110011000101101111010", + "101011100011100110001011011110101", + "1010111000111001100010110111101010", + "10101110001110011000101101111010101", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101", + "10101110001110011000101101111010101010", + "101011100011100110001011011110101010100", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001", + "101011100011100110001011011110101010100010", + "1010111000111001100010110111101010101000100", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011", + "1010111000111001100010110111101010101000100111", + "10101110001110011000101101111010101010001001111", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001", + "101011100011100110001011011110101010100010011111110010", + "1010111000111001100010110111101010101000100111111100100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010", + "1010111000111001100010110111101010101000100111111100100100", + "10101110001110011000101101111010101010001001111111001001000", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000", + "101011100011100110001011011110101010100010011111110010010001000000", + "1010111000111001100010110111101010101000100111111100100100010000001", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 2, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10", + "1010", + "101011", + "10101110", + "1010111000", + "101011100011", + "10101110001110", + "1010111000111001", + "101011100011100110", + "10101110001110011000", + "1010111000111001100010", + "101011100011100110001011", + "10101110001110011000101101", + "1010111000111001100010110111", + "101011100011100110001011011110", + "10101110001110011000101101111010", + "1010111000111001100010110111101010", + "101011100011100110001011011110101010", + "10101110001110011000101101111010101010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111", + "1010111000111001100010110111101010101000100111111100", + "101011100011100110001011011110101010100010011111110010", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100", + "101011100011100110001011011110101010100010011111110010010001", + "10101110001110011000101101111010101010001001111111001001000100", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 3, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "101", + "101011", + "101011100", + "101011100011", + "101011100011100", + "101011100011100110", + "101011100011100110001", + "101011100011100110001011", + "101011100011100110001011011", + "101011100011100110001011011110", + "101011100011100110001011011110101", + "101011100011100110001011011110101010", + "101011100011100110001011011110101010100", + "101011100011100110001011011110101010100010", + "101011100011100110001011011110101010100010011", + "101011100011100110001011011110101010100010011111", + "101011100011100110001011011110101010100010011111110", + "101011100011100110001011011110101010100010011111110010", + "101011100011100110001011011110101010100010011111110010010", + "101011100011100110001011011110101010100010011111110010010001", + "101011100011100110001011011110101010100010011111110010010001000", + "101011100011100110001011011110101010100010011111110010010001000000", + "101011100011100110001011011110101010100010011111110010010001000000101", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "101011100011100110001011011110101010100010011111110010010001000000101010010", + "101011100011100110001011011110101010100010011111110010010001000000101010010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 4, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010", + "10101110", + "101011100011", + "1010111000111001", + "10101110001110011000", + "101011100011100110001011", + "1010111000111001100010110111", + "10101110001110011000101101111010", + "101011100011100110001011011110101010", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100", + "10101110001110011000101101111010101010001001111111001001", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "1010111000111001100010110111101010101000100111111100100100010000001010100100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 8, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110", + "1010111000111001", + "101011100011100110001011", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000", + "101011100011100110001011011110101010100010011111", + "10101110001110011000101101111010101010001001111111001001", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 10, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000", + "10101110001110011000", + "101011100011100110001011011110", + "1010111000111001100010110111101010101000", + "10101110001110011000101101111010101010001001111111", + "101011100011100110001011011110101010100010011111110010010001", + "1010111000111001100010110111101010101000100111111100100100010000001010", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100111111111111111101000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 11, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001", + "1010111000111001100010", + "101011100011100110001011011110101", + "10101110001110011000101101111010101010001001", + "1010111000111001100010110111101010101000100111111100100", + "101011100011100110001011011110101010100010011111110010010001000000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111100", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 16, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001", + "10101110001110011000101101111010", + "101011100011100110001011011110101010100010011111", + "1010111000111001100010110111101010101000100111111100100100010000", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 31, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "1010111000111001100010110111101", + "10101110001110011000101101111010101010001001111111001001000100", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011", + "1010111000111001100010110111101010101000100111111100100100010000001010100100000110000110000111111001111111111111111010000000", + }, +}, +{ + .value = mc_dec128_from_string("32.7770000000000"), + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 32, + .expectEdges = { + "root", + "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000", + "10101110001110011000101101111010", + "1010111000111001100010110111101010101000100111111100100100010000", + "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 1, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1", + "11", + "110", + "1101", + "11011", + "110111", + "1101110", + "11011100", + "110111000", + "1101110001", + "11011100011", + "110111000111", + "1101110001110", + "11011100011100", + "110111000111000", + "1101110001110001", + "11011100011100011", + "110111000111000111", + "1101110001110001110", + "11011100011100011101", + "110111000111000111010", + "1101110001110001110100", + "11011100011100011101001", + "110111000111000111010011", + "1101110001110001110100111", + "11011100011100011101001111", + "110111000111000111010011110", + "1101110001110001110100111100", + "11011100011100011101001111000", + "110111000111000111010011110000", + "1101110001110001110100111100000", + "11011100011100011101001111000000", + "110111000111000111010011110000001", + "1101110001110001110100111100000010", + "11011100011100011101001111000000100", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001", + "11011100011100011101001111000000100010", + "110111000111000111010011110000001000100", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010", + "110111000111000111010011110000001000100101", + "1101110001110001110100111100000010001001011", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110", + "1101110001110001110100111100000010001001011101", + "11011100011100011101001111000000100010010111010", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001", + "110111000111000111010011110000001000100101110100000010", + "1101110001110001110100111100000010001001011101000000101", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100", + "1101110001110001110100111100000010001001011101000000101001", + "11011100011100011101001111000000100010010111010000001010011", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101", + "110111000111000111010011110000001000100101110100000010100110101010", + "1101110001110001110100111100000010001001011101000000101001101010100", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 2, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11", + "1101", + "110111", + "11011100", + "1101110001", + "110111000111", + "11011100011100", + "1101110001110001", + "110111000111000111", + "11011100011100011101", + "1101110001110001110100", + "110111000111000111010011", + "11011100011100011101001111", + "1101110001110001110100111100", + "110111000111000111010011110000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010", + "110111000111000111010011110000001000", + "11011100011100011101001111000000100010", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000", + "1101110001110001110100111100000010001001011101000000", + "110111000111000111010011110000001000100101110100000010", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001", + "110111000111000111010011110000001000100101110100000010100110", + "11011100011100011101001111000000100010010111010000001010011010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 3, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "110", + "110111", + "110111000", + "110111000111", + "110111000111000", + "110111000111000111", + "110111000111000111010", + "110111000111000111010011", + "110111000111000111010011110", + "110111000111000111010011110000", + "110111000111000111010011110000001", + "110111000111000111010011110000001000", + "110111000111000111010011110000001000100", + "110111000111000111010011110000001000100101", + "110111000111000111010011110000001000100101110", + "110111000111000111010011110000001000100101110100", + "110111000111000111010011110000001000100101110100000", + "110111000111000111010011110000001000100101110100000010", + "110111000111000111010011110000001000100101110100000010100", + "110111000111000111010011110000001000100101110100000010100110", + "110111000111000111010011110000001000100101110100000010100110101", + "110111000111000111010011110000001000100101110100000010100110101010", + "110111000111000111010011110000001000100101110100000010100110101010001", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 4, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101", + "11011100", + "110111000111", + "1101110001110001", + "11011100011100011101", + "110111000111000111010011", + "1101110001110001110100111100", + "11011100011100011101001111000000", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 8, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100", + "1101110001110001", + "110111000111000111010011", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 10, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001", + "11011100011100011101", + "110111000111000111010011110000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 11, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011", + "1101110001110001110100", + "110111000111000111010011110000001", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101000000101", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 16, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001", + "11011100011100011101001111000000", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 31, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001110100111100000", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128(0) }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 32, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 1, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1", + "11", + "110", + "1101", + "11011", + "110111", + "1101110", + "11011100", + "110111000", + "1101110001", + "11011100011", + "110111000111", + "1101110001110", + "11011100011100", + "110111000111000", + "1101110001110001", + "11011100011100011", + "110111000111000111", + "1101110001110001110", + "11011100011100011101", + "110111000111000111010", + "1101110001110001110100", + "11011100011100011101001", + "110111000111000111010011", + "1101110001110001110100111", + "11011100011100011101001111", + "110111000111000111010011110", + "1101110001110001110100111100", + "11011100011100011101001111000", + "110111000111000111010011110000", + "1101110001110001110100111100000", + "11011100011100011101001111000000", + "110111000111000111010011110000001", + "1101110001110001110100111100000010", + "11011100011100011101001111000000100", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001", + "11011100011100011101001111000000100010", + "110111000111000111010011110000001000100", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010", + "110111000111000111010011110000001000100101", + "1101110001110001110100111100000010001001011", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110", + "1101110001110001110100111100000010001001011101", + "11011100011100011101001111000000100010010111010", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001", + "110111000111000111010011110000001000100101110100000010", + "1101110001110001110100111100000010001001011101000000101", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100", + "1101110001110001110100111100000010001001011101000000101001", + "11011100011100011101001111000000100010010111010000001010011", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101", + "110111000111000111010011110000001000100101110100000010100110101010", + "1101110001110001110100111100000010001001011101000000101001101010100", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 2, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11", + "1101", + "110111", + "11011100", + "1101110001", + "110111000111", + "11011100011100", + "1101110001110001", + "110111000111000111", + "11011100011100011101", + "1101110001110001110100", + "110111000111000111010011", + "11011100011100011101001111", + "1101110001110001110100111100", + "110111000111000111010011110000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010", + "110111000111000111010011110000001000", + "11011100011100011101001111000000100010", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000", + "1101110001110001110100111100000010001001011101000000", + "110111000111000111010011110000001000100101110100000010", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001", + "110111000111000111010011110000001000100101110100000010100110", + "11011100011100011101001111000000100010010111010000001010011010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 3, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "110", + "110111", + "110111000", + "110111000111", + "110111000111000", + "110111000111000111", + "110111000111000111010", + "110111000111000111010011", + "110111000111000111010011110", + "110111000111000111010011110000", + "110111000111000111010011110000001", + "110111000111000111010011110000001000", + "110111000111000111010011110000001000100", + "110111000111000111010011110000001000100101", + "110111000111000111010011110000001000100101110", + "110111000111000111010011110000001000100101110100", + "110111000111000111010011110000001000100101110100000", + "110111000111000111010011110000001000100101110100000010", + "110111000111000111010011110000001000100101110100000010100", + "110111000111000111010011110000001000100101110100000010100110", + "110111000111000111010011110000001000100101110100000010100110101", + "110111000111000111010011110000001000100101110100000010100110101010", + "110111000111000111010011110000001000100101110100000010100110101010001", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 4, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101", + "11011100", + "110111000111", + "1101110001110001", + "11011100011100011101", + "110111000111000111010011", + "1101110001110001110100111100", + "11011100011100011101001111000000", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 8, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100", + "1101110001110001", + "110111000111000111010011", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 10, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001", + "11011100011100011101", + "110111000111000111010011110000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 11, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011", + "1101110001110001110100", + "110111000111000111010011110000001", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101000000101", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 16, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001", + "11011100011100011101001111000000", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 31, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001110100111100000", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("0.123400000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 32, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 1, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1", + "11", + "110", + "1101", + "11011", + "110111", + "1101110", + "11011100", + "110111000", + "1101110001", + "11011100011", + "110111000111", + "1101110001110", + "11011100011100", + "110111000111000", + "1101110001110001", + "11011100011100011", + "110111000111000111", + "1101110001110001110", + "11011100011100011101", + "110111000111000111010", + "1101110001110001110100", + "11011100011100011101001", + "110111000111000111010011", + "1101110001110001110100111", + "11011100011100011101001111", + "110111000111000111010011110", + "1101110001110001110100111100", + "11011100011100011101001111000", + "110111000111000111010011110000", + "1101110001110001110100111100000", + "11011100011100011101001111000000", + "110111000111000111010011110000001", + "1101110001110001110100111100000010", + "11011100011100011101001111000000100", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001", + "11011100011100011101001111000000100010", + "110111000111000111010011110000001000100", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010", + "110111000111000111010011110000001000100101", + "1101110001110001110100111100000010001001011", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110", + "1101110001110001110100111100000010001001011101", + "11011100011100011101001111000000100010010111010", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001", + "110111000111000111010011110000001000100101110100000010", + "1101110001110001110100111100000010001001011101000000101", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100", + "1101110001110001110100111100000010001001011101000000101001", + "11011100011100011101001111000000100010010111010000001010011", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101", + "110111000111000111010011110000001000100101110100000010100110101010", + "1101110001110001110100111100000010001001011101000000101001101010100", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 2, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11", + "1101", + "110111", + "11011100", + "1101110001", + "110111000111", + "11011100011100", + "1101110001110001", + "110111000111000111", + "11011100011100011101", + "1101110001110001110100", + "110111000111000111010011", + "11011100011100011101001111", + "1101110001110001110100111100", + "110111000111000111010011110000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010", + "110111000111000111010011110000001000", + "11011100011100011101001111000000100010", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000", + "1101110001110001110100111100000010001001011101000000", + "110111000111000111010011110000001000100101110100000010", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001", + "110111000111000111010011110000001000100101110100000010100110", + "11011100011100011101001111000000100010010111010000001010011010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 3, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "110", + "110111", + "110111000", + "110111000111", + "110111000111000", + "110111000111000111", + "110111000111000111010", + "110111000111000111010011", + "110111000111000111010011110", + "110111000111000111010011110000", + "110111000111000111010011110000001", + "110111000111000111010011110000001000", + "110111000111000111010011110000001000100", + "110111000111000111010011110000001000100101", + "110111000111000111010011110000001000100101110", + "110111000111000111010011110000001000100101110100", + "110111000111000111010011110000001000100101110100000", + "110111000111000111010011110000001000100101110100000010", + "110111000111000111010011110000001000100101110100000010100", + "110111000111000111010011110000001000100101110100000010100110", + "110111000111000111010011110000001000100101110100000010100110101", + "110111000111000111010011110000001000100101110100000010100110101010", + "110111000111000111010011110000001000100101110100000010100110101010001", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 4, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101", + "11011100", + "110111000111", + "1101110001110001", + "11011100011100011101", + "110111000111000111010011", + "1101110001110001110100111100", + "11011100011100011101001111000000", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 8, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100", + "1101110001110001", + "110111000111000111010011", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 10, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001", + "11011100011100011101", + "110111000111000111010011110000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 11, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011", + "1101110001110001110100", + "110111000111000111010011110000001", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101000000101", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 16, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001", + "11011100011100011101001111000000", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 31, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001110100111100000", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = mc_dec128_from_string("-54.3210000000000") }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 32, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 1, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1", + "11", + "110", + "1101", + "11011", + "110111", + "1101110", + "11011100", + "110111000", + "1101110001", + "11011100011", + "110111000111", + "1101110001110", + "11011100011100", + "110111000111000", + "1101110001110001", + "11011100011100011", + "110111000111000111", + "1101110001110001110", + "11011100011100011101", + "110111000111000111010", + "1101110001110001110100", + "11011100011100011101001", + "110111000111000111010011", + "1101110001110001110100111", + "11011100011100011101001111", + "110111000111000111010011110", + "1101110001110001110100111100", + "11011100011100011101001111000", + "110111000111000111010011110000", + "1101110001110001110100111100000", + "11011100011100011101001111000000", + "110111000111000111010011110000001", + "1101110001110001110100111100000010", + "11011100011100011101001111000000100", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001", + "11011100011100011101001111000000100010", + "110111000111000111010011110000001000100", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010", + "110111000111000111010011110000001000100101", + "1101110001110001110100111100000010001001011", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110", + "1101110001110001110100111100000010001001011101", + "11011100011100011101001111000000100010010111010", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001", + "110111000111000111010011110000001000100101110100000010", + "1101110001110001110100111100000010001001011101000000101", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100", + "1101110001110001110100111100000010001001011101000000101001", + "11011100011100011101001111000000100010010111010000001010011", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101", + "110111000111000111010011110000001000100101110100000010100110101010", + "1101110001110001110100111100000010001001011101000000101001101010100", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 2, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11", + "1101", + "110111", + "11011100", + "1101110001", + "110111000111", + "11011100011100", + "1101110001110001", + "110111000111000111", + "11011100011100011101", + "1101110001110001110100", + "110111000111000111010011", + "11011100011100011101001111", + "1101110001110001110100111100", + "110111000111000111010011110000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010", + "110111000111000111010011110000001000", + "11011100011100011101001111000000100010", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000", + "1101110001110001110100111100000010001001011101000000", + "110111000111000111010011110000001000100101110100000010", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001", + "110111000111000111010011110000001000100101110100000010100110", + "11011100011100011101001111000000100010010111010000001010011010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 3, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "110", + "110111", + "110111000", + "110111000111", + "110111000111000", + "110111000111000111", + "110111000111000111010", + "110111000111000111010011", + "110111000111000111010011110", + "110111000111000111010011110000", + "110111000111000111010011110000001", + "110111000111000111010011110000001000", + "110111000111000111010011110000001000100", + "110111000111000111010011110000001000100101", + "110111000111000111010011110000001000100101110", + "110111000111000111010011110000001000100101110100", + "110111000111000111010011110000001000100101110100000", + "110111000111000111010011110000001000100101110100000010", + "110111000111000111010011110000001000100101110100000010100", + "110111000111000111010011110000001000100101110100000010100110", + "110111000111000111010011110000001000100101110100000010100110101", + "110111000111000111010011110000001000100101110100000010100110101010", + "110111000111000111010011110000001000100101110100000010100110101010001", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 4, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101", + "11011100", + "110111000111", + "1101110001110001", + "11011100011100011101", + "110111000111000111010011", + "1101110001110001110100111100", + "11011100011100011101001111000000", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 8, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100", + "1101110001110001", + "110111000111000111010011", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 10, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001", + "11011100011100011101", + "110111000111000111010011110000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 11, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011", + "1101110001110001110100", + "110111000111000111010011110000001", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101000000101", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 16, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001", + "11011100011100011101001111000000", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 31, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001110100111100000", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 32, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 1, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1", + "11", + "110", + "1101", + "11011", + "110111", + "1101110", + "11011100", + "110111000", + "1101110001", + "11011100011", + "110111000111", + "1101110001110", + "11011100011100", + "110111000111000", + "1101110001110001", + "11011100011100011", + "110111000111000111", + "1101110001110001110", + "11011100011100011101", + "110111000111000111010", + "1101110001110001110100", + "11011100011100011101001", + "110111000111000111010011", + "1101110001110001110100111", + "11011100011100011101001111", + "110111000111000111010011110", + "1101110001110001110100111100", + "11011100011100011101001111000", + "110111000111000111010011110000", + "1101110001110001110100111100000", + "11011100011100011101001111000000", + "110111000111000111010011110000001", + "1101110001110001110100111100000010", + "11011100011100011101001111000000100", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001", + "11011100011100011101001111000000100010", + "110111000111000111010011110000001000100", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010", + "110111000111000111010011110000001000100101", + "1101110001110001110100111100000010001001011", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110", + "1101110001110001110100111100000010001001011101", + "11011100011100011101001111000000100010010111010", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001", + "110111000111000111010011110000001000100101110100000010", + "1101110001110001110100111100000010001001011101000000101", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100", + "1101110001110001110100111100000010001001011101000000101001", + "11011100011100011101001111000000100010010111010000001010011", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101", + "110111000111000111010011110000001000100101110100000010100110101010", + "1101110001110001110100111100000010001001011101000000101001101010100", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 2, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11", + "1101", + "110111", + "11011100", + "1101110001", + "110111000111", + "11011100011100", + "1101110001110001", + "110111000111000111", + "11011100011100011101", + "1101110001110001110100", + "110111000111000111010011", + "11011100011100011101001111", + "1101110001110001110100111100", + "110111000111000111010011110000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010", + "110111000111000111010011110000001000", + "11011100011100011101001111000000100010", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000", + "1101110001110001110100111100000010001001011101000000", + "110111000111000111010011110000001000100101110100000010", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001", + "110111000111000111010011110000001000100101110100000010100110", + "11011100011100011101001111000000100010010111010000001010011010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 3, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "110", + "110111", + "110111000", + "110111000111", + "110111000111000", + "110111000111000111", + "110111000111000111010", + "110111000111000111010011", + "110111000111000111010011110", + "110111000111000111010011110000", + "110111000111000111010011110000001", + "110111000111000111010011110000001000", + "110111000111000111010011110000001000100", + "110111000111000111010011110000001000100101", + "110111000111000111010011110000001000100101110", + "110111000111000111010011110000001000100101110100", + "110111000111000111010011110000001000100101110100000", + "110111000111000111010011110000001000100101110100000010", + "110111000111000111010011110000001000100101110100000010100", + "110111000111000111010011110000001000100101110100000010100110", + "110111000111000111010011110000001000100101110100000010100110101", + "110111000111000111010011110000001000100101110100000010100110101010", + "110111000111000111010011110000001000100101110100000010100110101010001", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 4, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101", + "11011100", + "110111000111", + "1101110001110001", + "11011100011100011101", + "110111000111000111010011", + "1101110001110001110100111100", + "11011100011100011101001111000000", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 8, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100", + "1101110001110001", + "110111000111000111010011", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 10, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001", + "11011100011100011101", + "110111000111000111010011110000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 11, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011", + "1101110001110001110100", + "110111000111000111010011110000001", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101000000101", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 16, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001", + "11011100011100011101001111000000", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 31, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001110100111100000", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 32, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 1, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1", + "11", + "110", + "1101", + "11011", + "110111", + "1101110", + "11011100", + "110111000", + "1101110001", + "11011100011", + "110111000111", + "1101110001110", + "11011100011100", + "110111000111000", + "1101110001110001", + "11011100011100011", + "110111000111000111", + "1101110001110001110", + "11011100011100011101", + "110111000111000111010", + "1101110001110001110100", + "11011100011100011101001", + "110111000111000111010011", + "1101110001110001110100111", + "11011100011100011101001111", + "110111000111000111010011110", + "1101110001110001110100111100", + "11011100011100011101001111000", + "110111000111000111010011110000", + "1101110001110001110100111100000", + "11011100011100011101001111000000", + "110111000111000111010011110000001", + "1101110001110001110100111100000010", + "11011100011100011101001111000000100", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001", + "11011100011100011101001111000000100010", + "110111000111000111010011110000001000100", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010", + "110111000111000111010011110000001000100101", + "1101110001110001110100111100000010001001011", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110", + "1101110001110001110100111100000010001001011101", + "11011100011100011101001111000000100010010111010", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001", + "110111000111000111010011110000001000100101110100000010", + "1101110001110001110100111100000010001001011101000000101", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100", + "1101110001110001110100111100000010001001011101000000101001", + "11011100011100011101001111000000100010010111010000001010011", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101", + "110111000111000111010011110000001000100101110100000010100110101010", + "1101110001110001110100111100000010001001011101000000101001101010100", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 2, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11", + "1101", + "110111", + "11011100", + "1101110001", + "110111000111", + "11011100011100", + "1101110001110001", + "110111000111000111", + "11011100011100011101", + "1101110001110001110100", + "110111000111000111010011", + "11011100011100011101001111", + "1101110001110001110100111100", + "110111000111000111010011110000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010", + "110111000111000111010011110000001000", + "11011100011100011101001111000000100010", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000", + "1101110001110001110100111100000010001001011101000000", + "110111000111000111010011110000001000100101110100000010", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001", + "110111000111000111010011110000001000100101110100000010100110", + "11011100011100011101001111000000100010010111010000001010011010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 3, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "110", + "110111", + "110111000", + "110111000111", + "110111000111000", + "110111000111000111", + "110111000111000111010", + "110111000111000111010011", + "110111000111000111010011110", + "110111000111000111010011110000", + "110111000111000111010011110000001", + "110111000111000111010011110000001000", + "110111000111000111010011110000001000100", + "110111000111000111010011110000001000100101", + "110111000111000111010011110000001000100101110", + "110111000111000111010011110000001000100101110100", + "110111000111000111010011110000001000100101110100000", + "110111000111000111010011110000001000100101110100000010", + "110111000111000111010011110000001000100101110100000010100", + "110111000111000111010011110000001000100101110100000010100110", + "110111000111000111010011110000001000100101110100000010100110101", + "110111000111000111010011110000001000100101110100000010100110101010", + "110111000111000111010011110000001000100101110100000010100110101010001", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 4, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101", + "11011100", + "110111000111", + "1101110001110001", + "11011100011100011101", + "110111000111000111010011", + "1101110001110001110100111100", + "11011100011100011101001111000000", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 8, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100", + "1101110001110001", + "110111000111000111010011", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 10, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001", + "11011100011100011101", + "110111000111000111010011110000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 11, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011", + "1101110001110001110100", + "110111000111000111010011110000001", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101000000101", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 16, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001", + "11011100011100011101001111000000", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 31, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001110100111100000", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 32, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 1, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1", + "11", + "110", + "1101", + "11011", + "110111", + "1101110", + "11011100", + "110111000", + "1101110001", + "11011100011", + "110111000111", + "1101110001110", + "11011100011100", + "110111000111000", + "1101110001110001", + "11011100011100011", + "110111000111000111", + "1101110001110001110", + "11011100011100011101", + "110111000111000111010", + "1101110001110001110100", + "11011100011100011101001", + "110111000111000111010011", + "1101110001110001110100111", + "11011100011100011101001111", + "110111000111000111010011110", + "1101110001110001110100111100", + "11011100011100011101001111000", + "110111000111000111010011110000", + "1101110001110001110100111100000", + "11011100011100011101001111000000", + "110111000111000111010011110000001", + "1101110001110001110100111100000010", + "11011100011100011101001111000000100", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001", + "11011100011100011101001111000000100010", + "110111000111000111010011110000001000100", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010", + "110111000111000111010011110000001000100101", + "1101110001110001110100111100000010001001011", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110", + "1101110001110001110100111100000010001001011101", + "11011100011100011101001111000000100010010111010", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001", + "110111000111000111010011110000001000100101110100000010", + "1101110001110001110100111100000010001001011101000000101", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100", + "1101110001110001110100111100000010001001011101000000101001", + "11011100011100011101001111000000100010010111010000001010011", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101", + "110111000111000111010011110000001000100101110100000010100110101010", + "1101110001110001110100111100000010001001011101000000101001101010100", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 2, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11", + "1101", + "110111", + "11011100", + "1101110001", + "110111000111", + "11011100011100", + "1101110001110001", + "110111000111000111", + "11011100011100011101", + "1101110001110001110100", + "110111000111000111010011", + "11011100011100011101001111", + "1101110001110001110100111100", + "110111000111000111010011110000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010", + "110111000111000111010011110000001000", + "11011100011100011101001111000000100010", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000", + "1101110001110001110100111100000010001001011101000000", + "110111000111000111010011110000001000100101110100000010", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001", + "110111000111000111010011110000001000100101110100000010100110", + "11011100011100011101001111000000100010010111010000001010011010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 3, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "110", + "110111", + "110111000", + "110111000111", + "110111000111000", + "110111000111000111", + "110111000111000111010", + "110111000111000111010011", + "110111000111000111010011110", + "110111000111000111010011110000", + "110111000111000111010011110000001", + "110111000111000111010011110000001000", + "110111000111000111010011110000001000100", + "110111000111000111010011110000001000100101", + "110111000111000111010011110000001000100101110", + "110111000111000111010011110000001000100101110100", + "110111000111000111010011110000001000100101110100000", + "110111000111000111010011110000001000100101110100000010", + "110111000111000111010011110000001000100101110100000010100", + "110111000111000111010011110000001000100101110100000010100110", + "110111000111000111010011110000001000100101110100000010100110101", + "110111000111000111010011110000001000100101110100000010100110101010", + "110111000111000111010011110000001000100101110100000010100110101010001", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 4, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101", + "11011100", + "110111000111", + "1101110001110001", + "11011100011100011101", + "110111000111000111010011", + "1101110001110001110100111100", + "11011100011100011101001111000000", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 8, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100", + "1101110001110001", + "110111000111000111010011", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 10, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001", + "11011100011100011101", + "110111000111000111010011110000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 11, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011", + "1101110001110001110100", + "110111000111000111010011110000001", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101000000101", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 16, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001", + "11011100011100011101001111000000", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 31, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001110100111100000", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 32, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 1, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1", + "11", + "110", + "1101", + "11011", + "110111", + "1101110", + "11011100", + "110111000", + "1101110001", + "11011100011", + "110111000111", + "1101110001110", + "11011100011100", + "110111000111000", + "1101110001110001", + "11011100011100011", + "110111000111000111", + "1101110001110001110", + "11011100011100011101", + "110111000111000111010", + "1101110001110001110100", + "11011100011100011101001", + "110111000111000111010011", + "1101110001110001110100111", + "11011100011100011101001111", + "110111000111000111010011110", + "1101110001110001110100111100", + "11011100011100011101001111000", + "110111000111000111010011110000", + "1101110001110001110100111100000", + "11011100011100011101001111000000", + "110111000111000111010011110000001", + "1101110001110001110100111100000010", + "11011100011100011101001111000000100", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001", + "11011100011100011101001111000000100010", + "110111000111000111010011110000001000100", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010", + "110111000111000111010011110000001000100101", + "1101110001110001110100111100000010001001011", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110", + "1101110001110001110100111100000010001001011101", + "11011100011100011101001111000000100010010111010", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001", + "110111000111000111010011110000001000100101110100000010", + "1101110001110001110100111100000010001001011101000000101", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100", + "1101110001110001110100111100000010001001011101000000101001", + "11011100011100011101001111000000100010010111010000001010011", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101", + "110111000111000111010011110000001000100101110100000010100110101010", + "1101110001110001110100111100000010001001011101000000101001101010100", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 2, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11", + "1101", + "110111", + "11011100", + "1101110001", + "110111000111", + "11011100011100", + "1101110001110001", + "110111000111000111", + "11011100011100011101", + "1101110001110001110100", + "110111000111000111010011", + "11011100011100011101001111", + "1101110001110001110100111100", + "110111000111000111010011110000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010", + "110111000111000111010011110000001000", + "11011100011100011101001111000000100010", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000", + "1101110001110001110100111100000010001001011101000000", + "110111000111000111010011110000001000100101110100000010", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001", + "110111000111000111010011110000001000100101110100000010100110", + "11011100011100011101001111000000100010010111010000001010011010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 3, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "110", + "110111", + "110111000", + "110111000111", + "110111000111000", + "110111000111000111", + "110111000111000111010", + "110111000111000111010011", + "110111000111000111010011110", + "110111000111000111010011110000", + "110111000111000111010011110000001", + "110111000111000111010011110000001000", + "110111000111000111010011110000001000100", + "110111000111000111010011110000001000100101", + "110111000111000111010011110000001000100101110", + "110111000111000111010011110000001000100101110100", + "110111000111000111010011110000001000100101110100000", + "110111000111000111010011110000001000100101110100000010", + "110111000111000111010011110000001000100101110100000010100", + "110111000111000111010011110000001000100101110100000010100110", + "110111000111000111010011110000001000100101110100000010100110101", + "110111000111000111010011110000001000100101110100000010100110101010", + "110111000111000111010011110000001000100101110100000010100110101010001", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "110111000111000111010011110000001000100101110100000010100110101010001010101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 4, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101", + "11011100", + "110111000111", + "1101110001110001", + "11011100011100011101", + "110111000111000111010011", + "1101110001110001110100111100", + "11011100011100011101001111000000", + "110111000111000111010011110000001000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000", + "11011100011100011101001111000000100010010111010000001010", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 8, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100", + "1101110001110001", + "110111000111000111010011", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001", + "110111000111000111010011110000001000100101110100", + "11011100011100011101001111000000100010010111010000001010", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 10, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001", + "11011100011100011101", + "110111000111000111010011110000", + "1101110001110001110100111100000010001001", + "11011100011100011101001111000000100010010111010000", + "110111000111000111010011110000001000100101110100000010100110", + "1101110001110001110100111100000010001001011101000000101001101010100010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111111111111111111010000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 11, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011", + "1101110001110001110100", + "110111000111000111010011110000001", + "11011100011100011101001111000000100010010111", + "1101110001110001110100111100000010001001011101000000101", + "110111000111000111010011110000001000100101110100000010100110101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111111", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 16, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001", + "11011100011100011101001111000000", + "110111000111000111010011110000001000100101110100", + "1101110001110001110100111100000010001001011101000000101001101010", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 31, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "1101110001110001110100111100000", + "11011100011100011101001111000000100010010111010000001010011010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111", + "1101110001110001110100111100000010001001011101000000101001101010100010101011001010111111111111111111111111111111110100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_POSITIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 32, + .expectEdges = { + "root", + "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000", + "11011100011100011101001111000000", + "1101110001110001110100111100000010001001011101000000101001101010", + "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 1, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0", + "00", + "001", + "0010", + "00100", + "001000", + "0010001", + "00100011", + "001000111", + "0010001110", + "00100011100", + "001000111000", + "0010001110001", + "00100011100011", + "001000111000111", + "0010001110001110", + "00100011100011100", + "001000111000111000", + "0010001110001110001", + "00100011100011100010", + "001000111000111000101", + "0010001110001110001011", + "00100011100011100010110", + "001000111000111000101100", + "0010001110001110001011000", + "00100011100011100010110000", + "001000111000111000101100001", + "0010001110001110001011000011", + "00100011100011100010110000111", + "001000111000111000101100001111", + "0010001110001110001011000011111", + "00100011100011100010110000111111", + "001000111000111000101100001111110", + "0010001110001110001011000011111101", + "00100011100011100010110000111111011", + "001000111000111000101100001111110111", + "0010001110001110001011000011111101110", + "00100011100011100010110000111111011101", + "001000111000111000101100001111110111011", + "0010001110001110001011000011111101110110", + "00100011100011100010110000111111011101101", + "001000111000111000101100001111110111011010", + "0010001110001110001011000011111101110110100", + "00100011100011100010110000111111011101101000", + "001000111000111000101100001111110111011010001", + "0010001110001110001011000011111101110110100010", + "00100011100011100010110000111111011101101000101", + "001000111000111000101100001111110111011010001011", + "0010001110001110001011000011111101110110100010111", + "00100011100011100010110000111111011101101000101111", + "001000111000111000101100001111110111011010001011111", + "0010001110001110001011000011111101110110100010111111", + "00100011100011100010110000111111011101101000101111110", + "001000111000111000101100001111110111011010001011111101", + "0010001110001110001011000011111101110110100010111111010", + "00100011100011100010110000111111011101101000101111110101", + "001000111000111000101100001111110111011010001011111101011", + "0010001110001110001011000011111101110110100010111111010110", + "00100011100011100010110000111111011101101000101111110101100", + "001000111000111000101100001111110111011010001011111101011001", + "0010001110001110001011000011111101110110100010111111010110010", + "00100011100011100010110000111111011101101000101111110101100101", + "001000111000111000101100001111110111011010001011111101011001010", + "0010001110001110001011000011111101110110100010111111010110010101", + "00100011100011100010110000111111011101101000101111110101100101010", + "001000111000111000101100001111110111011010001011111101011001010101", + "0010001110001110001011000011111101110110100010111111010110010101011", + "00100011100011100010110000111111011101101000101111110101100101010111", + "001000111000111000101100001111110111011010001011111101011001010101110", + "0010001110001110001011000011111101110110100010111111010110010101011101", + "00100011100011100010110000111111011101101000101111110101100101010111010", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "0010001110001110001011000011111101110110100010111111010110010101011101010", + "00100011100011100010110000111111011101101000101111110101100101010111010101", + "001000111000111000101100001111110111011010001011111101011001010101110101010", + "0010001110001110001011000011111101110110100010111111010110010101011101010100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001", + "001000111000111000101100001111110111011010001011111101011001010101110101010011", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 2, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00", + "0010", + "001000", + "00100011", + "0010001110", + "001000111000", + "00100011100011", + "0010001110001110", + "001000111000111000", + "00100011100011100010", + "0010001110001110001011", + "001000111000111000101100", + "00100011100011100010110000", + "0010001110001110001011000011", + "001000111000111000101100001111", + "00100011100011100010110000111111", + "0010001110001110001011000011111101", + "001000111000111000101100001111110111", + "00100011100011100010110000111111011101", + "0010001110001110001011000011111101110110", + "001000111000111000101100001111110111011010", + "00100011100011100010110000111111011101101000", + "0010001110001110001011000011111101110110100010", + "001000111000111000101100001111110111011010001011", + "00100011100011100010110000111111011101101000101111", + "0010001110001110001011000011111101110110100010111111", + "001000111000111000101100001111110111011010001011111101", + "00100011100011100010110000111111011101101000101111110101", + "0010001110001110001011000011111101110110100010111111010110", + "001000111000111000101100001111110111011010001011111101011001", + "00100011100011100010110000111111011101101000101111110101100101", + "0010001110001110001011000011111101110110100010111111010110010101", + "001000111000111000101100001111110111011010001011111101011001010101", + "00100011100011100010110000111111011101101000101111110101100101010111", + "0010001110001110001011000011111101110110100010111111010110010101011101", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "00100011100011100010110000111111011101101000101111110101100101010111010101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100", + "001000111000111000101100001111110111011010001011111101011001010101110101010011", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 3, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "001", + "001000", + "001000111", + "001000111000", + "001000111000111", + "001000111000111000", + "001000111000111000101", + "001000111000111000101100", + "001000111000111000101100001", + "001000111000111000101100001111", + "001000111000111000101100001111110", + "001000111000111000101100001111110111", + "001000111000111000101100001111110111011", + "001000111000111000101100001111110111011010", + "001000111000111000101100001111110111011010001", + "001000111000111000101100001111110111011010001011", + "001000111000111000101100001111110111011010001011111", + "001000111000111000101100001111110111011010001011111101", + "001000111000111000101100001111110111011010001011111101011", + "001000111000111000101100001111110111011010001011111101011001", + "001000111000111000101100001111110111011010001011111101011001010", + "001000111000111000101100001111110111011010001011111101011001010101", + "001000111000111000101100001111110111011010001011111101011001010101110", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "001000111000111000101100001111110111011010001011111101011001010101110101010", + "001000111000111000101100001111110111011010001011111101011001010101110101010011", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 4, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010", + "00100011", + "001000111000", + "0010001110001110", + "00100011100011100010", + "001000111000111000101100", + "0010001110001110001011000011", + "00100011100011100010110000111111", + "001000111000111000101100001111110111", + "0010001110001110001011000011111101110110", + "00100011100011100010110000111111011101101000", + "001000111000111000101100001111110111011010001011", + "0010001110001110001011000011111101110110100010111111", + "00100011100011100010110000111111011101101000101111110101", + "001000111000111000101100001111110111011010001011111101011001", + "0010001110001110001011000011111101110110100010111111010110010101", + "00100011100011100010110000111111011101101000101111110101100101010111", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 8, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00100011", + "0010001110001110", + "001000111000111000101100", + "00100011100011100010110000111111", + "0010001110001110001011000011111101110110", + "001000111000111000101100001111110111011010001011", + "00100011100011100010110000111111011101101000101111110101", + "0010001110001110001011000011111101110110100010111111010110010101", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 10, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010001110", + "00100011100011100010", + "001000111000111000101100001111", + "0010001110001110001011000011111101110110", + "00100011100011100010110000111111011101101000101111", + "001000111000111000101100001111110111011010001011111101011001", + "0010001110001110001011000011111101110110100010111111010110010101011101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 11, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00100011100", + "0010001110001110001011", + "001000111000111000101100001111110", + "00100011100011100010110000111111011101101000", + "0010001110001110001011000011111101110110100010111111010", + "001000111000111000101100001111110111011010001011111101011001010101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 16, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010001110001110", + "00100011100011100010110000111111", + "001000111000111000101100001111110111011010001011", + "0010001110001110001011000011111101110110100010111111010110010101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 31, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010001110001110001011000011111", + "00100011100011100010110000111111011101101000101111110101100101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("12.3400000000000") }, + .sparsity = 32, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00100011100011100010110000111111", + "0010001110001110001011000011111101110110100010111111010110010101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("-21.0980000000000") }, + .sparsity = 1, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0", + "00", + "001", + "0010", + "00100", + "001000", + "0010001", + "00100011", + "001000111", + "0010001110", + "00100011100", + "001000111000", + "0010001110001", + "00100011100011", + "001000111000111", + "0010001110001110", + "00100011100011100", + "001000111000111000", + "0010001110001110001", + "00100011100011100010", + "001000111000111000101", + "0010001110001110001011", + "00100011100011100010110", + "001000111000111000101100", + "0010001110001110001011000", + "00100011100011100010110000", + "001000111000111000101100001", + "0010001110001110001011000011", + "00100011100011100010110000111", + "001000111000111000101100001111", + "0010001110001110001011000011111", + "00100011100011100010110000111111", + "001000111000111000101100001111110", + "0010001110001110001011000011111101", + "00100011100011100010110000111111011", + "001000111000111000101100001111110111", + "0010001110001110001011000011111101110", + "00100011100011100010110000111111011101", + "001000111000111000101100001111110111011", + "0010001110001110001011000011111101110110", + "00100011100011100010110000111111011101101", + "001000111000111000101100001111110111011010", + "0010001110001110001011000011111101110110100", + "00100011100011100010110000111111011101101000", + "001000111000111000101100001111110111011010001", + "0010001110001110001011000011111101110110100010", + "00100011100011100010110000111111011101101000101", + "001000111000111000101100001111110111011010001011", + "0010001110001110001011000011111101110110100010111", + "00100011100011100010110000111111011101101000101111", + "001000111000111000101100001111110111011010001011111", + "0010001110001110001011000011111101110110100010111111", + "00100011100011100010110000111111011101101000101111110", + "001000111000111000101100001111110111011010001011111101", + "0010001110001110001011000011111101110110100010111111010", + "00100011100011100010110000111111011101101000101111110101", + "001000111000111000101100001111110111011010001011111101011", + "0010001110001110001011000011111101110110100010111111010110", + "00100011100011100010110000111111011101101000101111110101100", + "001000111000111000101100001111110111011010001011111101011001", + "0010001110001110001011000011111101110110100010111111010110010", + "00100011100011100010110000111111011101101000101111110101100101", + "001000111000111000101100001111110111011010001011111101011001010", + "0010001110001110001011000011111101110110100010111111010110010101", + "00100011100011100010110000111111011101101000101111110101100101010", + "001000111000111000101100001111110111011010001011111101011001010101", + "0010001110001110001011000011111101110110100010111111010110010101011", + "00100011100011100010110000111111011101101000101111110101100101010111", + "001000111000111000101100001111110111011010001011111101011001010101110", + "0010001110001110001011000011111101110110100010111111010110010101011101", + "00100011100011100010110000111111011101101000101111110101100101010111010", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "0010001110001110001011000011111101110110100010111111010110010101011101010", + "00100011100011100010110000111111011101101000101111110101100101010111010101", + "001000111000111000101100001111110111011010001011111101011001010101110101010", + "0010001110001110001011000011111101110110100010111111010110010101011101010100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001", + "001000111000111000101100001111110111011010001011111101011001010101110101010011", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("-21.0980000000000") }, + .sparsity = 2, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00", + "0010", + "001000", + "00100011", + "0010001110", + "001000111000", + "00100011100011", + "0010001110001110", + "001000111000111000", + "00100011100011100010", + "0010001110001110001011", + "001000111000111000101100", + "00100011100011100010110000", + "0010001110001110001011000011", + "001000111000111000101100001111", + "00100011100011100010110000111111", + "0010001110001110001011000011111101", + "001000111000111000101100001111110111", + "00100011100011100010110000111111011101", + "0010001110001110001011000011111101110110", + "001000111000111000101100001111110111011010", + "00100011100011100010110000111111011101101000", + "0010001110001110001011000011111101110110100010", + "001000111000111000101100001111110111011010001011", + "00100011100011100010110000111111011101101000101111", + "0010001110001110001011000011111101110110100010111111", + "001000111000111000101100001111110111011010001011111101", + "00100011100011100010110000111111011101101000101111110101", + "0010001110001110001011000011111101110110100010111111010110", + "001000111000111000101100001111110111011010001011111101011001", + "00100011100011100010110000111111011101101000101111110101100101", + "0010001110001110001011000011111101110110100010111111010110010101", + "001000111000111000101100001111110111011010001011111101011001010101", + "00100011100011100010110000111111011101101000101111110101100101010111", + "0010001110001110001011000011111101110110100010111111010110010101011101", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "00100011100011100010110000111111011101101000101111110101100101010111010101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100", + "001000111000111000101100001111110111011010001011111101011001010101110101010011", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("-21.0980000000000") }, + .sparsity = 3, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "001", + "001000", + "001000111", + "001000111000", + "001000111000111", + "001000111000111000", + "001000111000111000101", + "001000111000111000101100", + "001000111000111000101100001", + "001000111000111000101100001111", + "001000111000111000101100001111110", + "001000111000111000101100001111110111", + "001000111000111000101100001111110111011", + "001000111000111000101100001111110111011010", + "001000111000111000101100001111110111011010001", + "001000111000111000101100001111110111011010001011", + "001000111000111000101100001111110111011010001011111", + "001000111000111000101100001111110111011010001011111101", + "001000111000111000101100001111110111011010001011111101011", + "001000111000111000101100001111110111011010001011111101011001", + "001000111000111000101100001111110111011010001011111101011001010", + "001000111000111000101100001111110111011010001011111101011001010101", + "001000111000111000101100001111110111011010001011111101011001010101110", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "001000111000111000101100001111110111011010001011111101011001010101110101010", + "001000111000111000101100001111110111011010001011111101011001010101110101010011", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("-21.0980000000000") }, + .sparsity = 4, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010", + "00100011", + "001000111000", + "0010001110001110", + "00100011100011100010", + "001000111000111000101100", + "0010001110001110001011000011", + "00100011100011100010110000111111", + "001000111000111000101100001111110111", + "0010001110001110001011000011111101110110", + "00100011100011100010110000111111011101101000", + "001000111000111000101100001111110111011010001011", + "0010001110001110001011000011111101110110100010111111", + "00100011100011100010110000111111011101101000101111110101", + "001000111000111000101100001111110111011010001011111101011001", + "0010001110001110001011000011111101110110100010111111010110010101", + "00100011100011100010110000111111011101101000101111110101100101010111", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("-21.0980000000000") }, + .sparsity = 8, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00100011", + "0010001110001110", + "001000111000111000101100", + "00100011100011100010110000111111", + "0010001110001110001011000011111101110110", + "001000111000111000101100001111110111011010001011", + "00100011100011100010110000111111011101101000101111110101", + "0010001110001110001011000011111101110110100010111111010110010101", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("-21.0980000000000") }, + .sparsity = 10, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010001110", + "00100011100011100010", + "001000111000111000101100001111", + "0010001110001110001011000011111101110110", + "00100011100011100010110000111111011101101000101111", + "001000111000111000101100001111110111011010001011111101011001", + "0010001110001110001011000011111101110110100010111111010110010101011101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("-21.0980000000000") }, + .sparsity = 11, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00100011100", + "0010001110001110001011", + "001000111000111000101100001111110", + "00100011100011100010110000111111011101101000", + "0010001110001110001011000011111101110110100010111111010", + "001000111000111000101100001111110111011010001011111101011001010101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("-21.0980000000000") }, + .sparsity = 16, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010001110001110", + "00100011100011100010110000111111", + "001000111000111000101100001111110111011010001011", + "0010001110001110001011000011111101110110100010111111010110010101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("-21.0980000000000") }, + .sparsity = 31, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010001110001110001011000011111", + "00100011100011100010110000111111011101101000101111110101100101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = mc_dec128_from_string("-21.0980000000000") }, + .sparsity = 32, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00100011100011100010110000111111", + "0010001110001110001011000011111101110110100010111111010110010101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 1, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0", + "00", + "001", + "0010", + "00100", + "001000", + "0010001", + "00100011", + "001000111", + "0010001110", + "00100011100", + "001000111000", + "0010001110001", + "00100011100011", + "001000111000111", + "0010001110001110", + "00100011100011100", + "001000111000111000", + "0010001110001110001", + "00100011100011100010", + "001000111000111000101", + "0010001110001110001011", + "00100011100011100010110", + "001000111000111000101100", + "0010001110001110001011000", + "00100011100011100010110000", + "001000111000111000101100001", + "0010001110001110001011000011", + "00100011100011100010110000111", + "001000111000111000101100001111", + "0010001110001110001011000011111", + "00100011100011100010110000111111", + "001000111000111000101100001111110", + "0010001110001110001011000011111101", + "00100011100011100010110000111111011", + "001000111000111000101100001111110111", + "0010001110001110001011000011111101110", + "00100011100011100010110000111111011101", + "001000111000111000101100001111110111011", + "0010001110001110001011000011111101110110", + "00100011100011100010110000111111011101101", + "001000111000111000101100001111110111011010", + "0010001110001110001011000011111101110110100", + "00100011100011100010110000111111011101101000", + "001000111000111000101100001111110111011010001", + "0010001110001110001011000011111101110110100010", + "00100011100011100010110000111111011101101000101", + "001000111000111000101100001111110111011010001011", + "0010001110001110001011000011111101110110100010111", + "00100011100011100010110000111111011101101000101111", + "001000111000111000101100001111110111011010001011111", + "0010001110001110001011000011111101110110100010111111", + "00100011100011100010110000111111011101101000101111110", + "001000111000111000101100001111110111011010001011111101", + "0010001110001110001011000011111101110110100010111111010", + "00100011100011100010110000111111011101101000101111110101", + "001000111000111000101100001111110111011010001011111101011", + "0010001110001110001011000011111101110110100010111111010110", + "00100011100011100010110000111111011101101000101111110101100", + "001000111000111000101100001111110111011010001011111101011001", + "0010001110001110001011000011111101110110100010111111010110010", + "00100011100011100010110000111111011101101000101111110101100101", + "001000111000111000101100001111110111011010001011111101011001010", + "0010001110001110001011000011111101110110100010111111010110010101", + "00100011100011100010110000111111011101101000101111110101100101010", + "001000111000111000101100001111110111011010001011111101011001010101", + "0010001110001110001011000011111101110110100010111111010110010101011", + "00100011100011100010110000111111011101101000101111110101100101010111", + "001000111000111000101100001111110111011010001011111101011001010101110", + "0010001110001110001011000011111101110110100010111111010110010101011101", + "00100011100011100010110000111111011101101000101111110101100101010111010", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "0010001110001110001011000011111101110110100010111111010110010101011101010", + "00100011100011100010110000111111011101101000101111110101100101010111010101", + "001000111000111000101100001111110111011010001011111101011001010101110101010", + "0010001110001110001011000011111101110110100010111111010110010101011101010100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001", + "001000111000111000101100001111110111011010001011111101011001010101110101010011", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 2, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00", + "0010", + "001000", + "00100011", + "0010001110", + "001000111000", + "00100011100011", + "0010001110001110", + "001000111000111000", + "00100011100011100010", + "0010001110001110001011", + "001000111000111000101100", + "00100011100011100010110000", + "0010001110001110001011000011", + "001000111000111000101100001111", + "00100011100011100010110000111111", + "0010001110001110001011000011111101", + "001000111000111000101100001111110111", + "00100011100011100010110000111111011101", + "0010001110001110001011000011111101110110", + "001000111000111000101100001111110111011010", + "00100011100011100010110000111111011101101000", + "0010001110001110001011000011111101110110100010", + "001000111000111000101100001111110111011010001011", + "00100011100011100010110000111111011101101000101111", + "0010001110001110001011000011111101110110100010111111", + "001000111000111000101100001111110111011010001011111101", + "00100011100011100010110000111111011101101000101111110101", + "0010001110001110001011000011111101110110100010111111010110", + "001000111000111000101100001111110111011010001011111101011001", + "00100011100011100010110000111111011101101000101111110101100101", + "0010001110001110001011000011111101110110100010111111010110010101", + "001000111000111000101100001111110111011010001011111101011001010101", + "00100011100011100010110000111111011101101000101111110101100101010111", + "0010001110001110001011000011111101110110100010111111010110010101011101", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "00100011100011100010110000111111011101101000101111110101100101010111010101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100", + "001000111000111000101100001111110111011010001011111101011001010101110101010011", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 3, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "001", + "001000", + "001000111", + "001000111000", + "001000111000111", + "001000111000111000", + "001000111000111000101", + "001000111000111000101100", + "001000111000111000101100001", + "001000111000111000101100001111", + "001000111000111000101100001111110", + "001000111000111000101100001111110111", + "001000111000111000101100001111110111011", + "001000111000111000101100001111110111011010", + "001000111000111000101100001111110111011010001", + "001000111000111000101100001111110111011010001011", + "001000111000111000101100001111110111011010001011111", + "001000111000111000101100001111110111011010001011111101", + "001000111000111000101100001111110111011010001011111101011", + "001000111000111000101100001111110111011010001011111101011001", + "001000111000111000101100001111110111011010001011111101011001010", + "001000111000111000101100001111110111011010001011111101011001010101", + "001000111000111000101100001111110111011010001011111101011001010101110", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "001000111000111000101100001111110111011010001011111101011001010101110101010", + "001000111000111000101100001111110111011010001011111101011001010101110101010011", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 4, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010", + "00100011", + "001000111000", + "0010001110001110", + "00100011100011100010", + "001000111000111000101100", + "0010001110001110001011000011", + "00100011100011100010110000111111", + "001000111000111000101100001111110111", + "0010001110001110001011000011111101110110", + "00100011100011100010110000111111011101101000", + "001000111000111000101100001111110111011010001011", + "0010001110001110001011000011111101110110100010111111", + "00100011100011100010110000111111011101101000101111110101", + "001000111000111000101100001111110111011010001011111101011001", + "0010001110001110001011000011111101110110100010111111010110010101", + "00100011100011100010110000111111011101101000101111110101100101010111", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 8, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00100011", + "0010001110001110", + "001000111000111000101100", + "00100011100011100010110000111111", + "0010001110001110001011000011111101110110", + "001000111000111000101100001111110111011010001011", + "00100011100011100010110000111111011101101000101111110101", + "0010001110001110001011000011111101110110100010111111010110010101", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 10, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010001110", + "00100011100011100010", + "001000111000111000101100001111", + "0010001110001110001011000011111101110110", + "00100011100011100010110000111111011101101000101111", + "001000111000111000101100001111110111011010001011111101011001", + "0010001110001110001011000011111101110110100010111111010110010101011101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 11, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00100011100", + "0010001110001110001011", + "001000111000111000101100001111110", + "00100011100011100010110000111111011101101000", + "0010001110001110001011000011111101110110100010111111010", + "001000111000111000101100001111110111011010001011111101011001010101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 16, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010001110001110", + "00100011100011100010110000111111", + "001000111000111000101100001111110111011010001011", + "0010001110001110001011000011111101110110100010111111010110010101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 31, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010001110001110001011000011111", + "00100011100011100010110000111111011101101000101111110101100101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = true, .value = MC_DEC128_LARGEST_NEGATIVE }, + .max = { .set = true, .value = MC_DEC128_LARGEST_POSITIVE }, + .sparsity = 32, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00100011100011100010110000111111", + "0010001110001110001011000011111101110110100010111111010110010101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 1, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0", + "00", + "001", + "0010", + "00100", + "001000", + "0010001", + "00100011", + "001000111", + "0010001110", + "00100011100", + "001000111000", + "0010001110001", + "00100011100011", + "001000111000111", + "0010001110001110", + "00100011100011100", + "001000111000111000", + "0010001110001110001", + "00100011100011100010", + "001000111000111000101", + "0010001110001110001011", + "00100011100011100010110", + "001000111000111000101100", + "0010001110001110001011000", + "00100011100011100010110000", + "001000111000111000101100001", + "0010001110001110001011000011", + "00100011100011100010110000111", + "001000111000111000101100001111", + "0010001110001110001011000011111", + "00100011100011100010110000111111", + "001000111000111000101100001111110", + "0010001110001110001011000011111101", + "00100011100011100010110000111111011", + "001000111000111000101100001111110111", + "0010001110001110001011000011111101110", + "00100011100011100010110000111111011101", + "001000111000111000101100001111110111011", + "0010001110001110001011000011111101110110", + "00100011100011100010110000111111011101101", + "001000111000111000101100001111110111011010", + "0010001110001110001011000011111101110110100", + "00100011100011100010110000111111011101101000", + "001000111000111000101100001111110111011010001", + "0010001110001110001011000011111101110110100010", + "00100011100011100010110000111111011101101000101", + "001000111000111000101100001111110111011010001011", + "0010001110001110001011000011111101110110100010111", + "00100011100011100010110000111111011101101000101111", + "001000111000111000101100001111110111011010001011111", + "0010001110001110001011000011111101110110100010111111", + "00100011100011100010110000111111011101101000101111110", + "001000111000111000101100001111110111011010001011111101", + "0010001110001110001011000011111101110110100010111111010", + "00100011100011100010110000111111011101101000101111110101", + "001000111000111000101100001111110111011010001011111101011", + "0010001110001110001011000011111101110110100010111111010110", + "00100011100011100010110000111111011101101000101111110101100", + "001000111000111000101100001111110111011010001011111101011001", + "0010001110001110001011000011111101110110100010111111010110010", + "00100011100011100010110000111111011101101000101111110101100101", + "001000111000111000101100001111110111011010001011111101011001010", + "0010001110001110001011000011111101110110100010111111010110010101", + "00100011100011100010110000111111011101101000101111110101100101010", + "001000111000111000101100001111110111011010001011111101011001010101", + "0010001110001110001011000011111101110110100010111111010110010101011", + "00100011100011100010110000111111011101101000101111110101100101010111", + "001000111000111000101100001111110111011010001011111101011001010101110", + "0010001110001110001011000011111101110110100010111111010110010101011101", + "00100011100011100010110000111111011101101000101111110101100101010111010", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "0010001110001110001011000011111101110110100010111111010110010101011101010", + "00100011100011100010110000111111011101101000101111110101100101010111010101", + "001000111000111000101100001111110111011010001011111101011001010101110101010", + "0010001110001110001011000011111101110110100010111111010110010101011101010100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001", + "001000111000111000101100001111110111011010001011111101011001010101110101010011", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 2, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00", + "0010", + "001000", + "00100011", + "0010001110", + "001000111000", + "00100011100011", + "0010001110001110", + "001000111000111000", + "00100011100011100010", + "0010001110001110001011", + "001000111000111000101100", + "00100011100011100010110000", + "0010001110001110001011000011", + "001000111000111000101100001111", + "00100011100011100010110000111111", + "0010001110001110001011000011111101", + "001000111000111000101100001111110111", + "00100011100011100010110000111111011101", + "0010001110001110001011000011111101110110", + "001000111000111000101100001111110111011010", + "00100011100011100010110000111111011101101000", + "0010001110001110001011000011111101110110100010", + "001000111000111000101100001111110111011010001011", + "00100011100011100010110000111111011101101000101111", + "0010001110001110001011000011111101110110100010111111", + "001000111000111000101100001111110111011010001011111101", + "00100011100011100010110000111111011101101000101111110101", + "0010001110001110001011000011111101110110100010111111010110", + "001000111000111000101100001111110111011010001011111101011001", + "00100011100011100010110000111111011101101000101111110101100101", + "0010001110001110001011000011111101110110100010111111010110010101", + "001000111000111000101100001111110111011010001011111101011001010101", + "00100011100011100010110000111111011101101000101111110101100101010111", + "0010001110001110001011000011111101110110100010111111010110010101011101", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "00100011100011100010110000111111011101101000101111110101100101010111010101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100", + "001000111000111000101100001111110111011010001011111101011001010101110101010011", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 3, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "001", + "001000", + "001000111", + "001000111000", + "001000111000111", + "001000111000111000", + "001000111000111000101", + "001000111000111000101100", + "001000111000111000101100001", + "001000111000111000101100001111", + "001000111000111000101100001111110", + "001000111000111000101100001111110111", + "001000111000111000101100001111110111011", + "001000111000111000101100001111110111011010", + "001000111000111000101100001111110111011010001", + "001000111000111000101100001111110111011010001011", + "001000111000111000101100001111110111011010001011111", + "001000111000111000101100001111110111011010001011111101", + "001000111000111000101100001111110111011010001011111101011", + "001000111000111000101100001111110111011010001011111101011001", + "001000111000111000101100001111110111011010001011111101011001010", + "001000111000111000101100001111110111011010001011111101011001010101", + "001000111000111000101100001111110111011010001011111101011001010101110", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "001000111000111000101100001111110111011010001011111101011001010101110101010", + "001000111000111000101100001111110111011010001011111101011001010101110101010011", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 4, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010", + "00100011", + "001000111000", + "0010001110001110", + "00100011100011100010", + "001000111000111000101100", + "0010001110001110001011000011", + "00100011100011100010110000111111", + "001000111000111000101100001111110111", + "0010001110001110001011000011111101110110", + "00100011100011100010110000111111011101101000", + "001000111000111000101100001111110111011010001011", + "0010001110001110001011000011111101110110100010111111", + "00100011100011100010110000111111011101101000101111110101", + "001000111000111000101100001111110111011010001011111101011001", + "0010001110001110001011000011111101110110100010111111010110010101", + "00100011100011100010110000111111011101101000101111110101100101010111", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 8, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00100011", + "0010001110001110", + "001000111000111000101100", + "00100011100011100010110000111111", + "0010001110001110001011000011111101110110", + "001000111000111000101100001111110111011010001011", + "00100011100011100010110000111111011101101000101111110101", + "0010001110001110001011000011111101110110100010111111010110010101", + "001000111000111000101100001111110111011010001011111101011001010101110101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 10, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010001110", + "00100011100011100010", + "001000111000111000101100001111", + "0010001110001110001011000011111101110110", + "00100011100011100010110000111111011101101000101111", + "001000111000111000101100001111110111011010001011111101011001", + "0010001110001110001011000011111101110110100010111111010110010101011101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000000000000000000110000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 11, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00100011100", + "0010001110001110001011", + "001000111000111000101100001111110", + "00100011100011100010110000111111011101101000", + "0010001110001110001011000011111101110110100010111111010", + "001000111000111000101100001111110111011010001011111101011001010101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000000", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 16, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010001110001110", + "00100011100011100010110000111111", + "001000111000111000101100001111110111011010001011", + "0010001110001110001011000011111101110110100010111111010110010101", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 31, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "0010001110001110001011000011111", + "00100011100011100010110000111111011101101000101111110101100101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000", + "0010001110001110001011000011111101110110100010111111010110010101011101010100110101000000000000000000000000000000001100000000", + }, +}, +{ + .value = MC_DEC128_LARGEST_NEGATIVE, + .min = { .set = false }, + .max = { .set = false }, + .sparsity = 32, + .expectEdges = { + "root", + "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000", + "00100011100011100010110000111111", + "0010001110001110001011000011111101110110100010111111010110010101", + "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000", + }, +}, diff --git a/test/data/range-min-cover/mincover_decimal128.cstruct b/test/data/range-min-cover/mincover_decimal128.cstruct new file mode 100644 index 000000000..20a96991c --- /dev/null +++ b/test/data/range-min-cover/mincover_decimal128.cstruct @@ -0,0 +1,4565 @@ +// This code is GENERATED! Do not edit! +// clang-format off +{ + .lowerBound = mc_dec128_from_string("-100.000000"), + .includeLowerBound = true, + .upperBound = mc_dec128_from_string("-100.000000"), + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = mc_dec128_from_string("-1000000000000000L") }, + .max = { .set = true, .value = MC_DEC128(0x7000000000000000L) }, + .expectMincoverStrings = { + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000000001", + }, +}, +{ + .lowerBound = mc_dec128_from_string("-100.000000"), + .includeLowerBound = true, + .upperBound = mc_dec128_from_string("-100.000000"), + .includeUpperBound = true, + .sparsity = 8, + .min = { .set = true, .value = mc_dec128_from_string("-1000000000000000L") }, + .max = { .set = true, .value = MC_DEC128(0x7000000000000000L) }, + .expectMincoverStrings = { + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000000001", + }, +}, +{ + .lowerBound = mc_dec128_from_string("-100.000000"), + .includeLowerBound = true, + .upperBound = mc_dec128_from_string("123456789.000000"), + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = mc_dec128_from_string("-1000000000000000L") }, + .max = { .set = true, .value = MC_DEC128(0x7000000000000000L) }, + .expectMincoverStrings = { + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000000001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000000000000110000000001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000011000000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000000000000110000001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000011000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000000000000110001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000011001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000000000000111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000000000001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000000001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111", + "01010001110001001111011111001000001101100101001111100101011101110100101001011", + "010100011100010011110111110010000011011001010011111001010111011101001010011", + "0101000111000100111101111100100000110110010100111110010101110111010010101", + "010100011100010011110111110010000011011001010011111001010111011101001011", + "0101000111000100111101111100100000110110010100111110010101110111010011", + "01010001110001001111011111001000001101100101001111100101011101110101", + "0101000111000100111101111100100000110110010100111110010101110111011", + "01010001110001001111011111001000001101100101001111100101011101111", + "0101000111000100111101111100100000110110010100111110010101111", + "010100011100010011110111110010000011011001010011111001011", + "0101000111000100111101111100100000110110010100111110011", + "01010001110001001111011111001000001101100101001111101", + "0101000111000100111101111100100000110110010100111111", + "0101000111000100111101111100100000110110010101", + "010100011100010011110111110010000011011001011", + "0101000111000100111101111100100000110110011", + "01010001110001001111011111001000001101101", + "0101000111000100111101111100100000110111", + "0101000111000100111101111100100000111", + "0101000111000100111101111100100001", + "010100011100010011110111110010001", + "01010001110001001111011111001001", + "0101000111000100111101111100101", + "010100011100010011110111110011", + "0101000111000100111101111101", + "010100011100010011110111111", + "010100011100010011111", + "0101000111000101", + "010100011100011", + "0101000111001", + "010100011101", + "01010001111", + "0101001", + "010101", + "01011", + "011", + "100", + "10100", + "101010", + "1010110", + "1010111000", + "10101110010000", + "101011100100010", + "10101110010001100", + "1010111001000110100", + "10101110010001101010000", + "1010111001000110101000100000000", + "101011100100011010100010000000100", + "1010111001000110101000100000001010", + "10101110010001101010001000000010110", + "1010111001000110101000100000001011100", + "101011100100011010100010000000101110100", + "1010111001000110101000100000001011101010", + "101011100100011010100010000000101110101100", + "1010111001000110101000100000001011101011010", + "10101110010001101010001000000010111010110110", + "101011100100011010100010000000101110101101110", + "101011100100011010100010000000101110101101111000000", + "1010111001000110101000100000001011101011011110000010", + "10101110010001101010001000000010111010110111100000110", + "101011100100011010100010000000101110101101111000001110000", + "10101110010001101010001000000010111010110111100000111000100000", + "1010111001000110101000100000001011101011011110000011100010000100", + "101011100100011010100010000000101110101101111000001110001000010100000", + "1010111001000110101000100000001011101011011110000011100010000101000010", + "101011100100011010100010000000101110101101111000001110001000010100001100", + "1010111001000110101000100000001011101011011110000011100010000101000011010", + "1010111001000110101000100000001011101011011110000011100010000101000011011000", + "10101110010001101010001000000010111010110111100000111000100001010000110110010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111111110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111111111110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111111111111000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111100110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111111111111001110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111100111110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111111111111001111110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111111111111001111111100", + }, +}, +{ + .lowerBound = mc_dec128_from_string("-100.000000"), + .includeLowerBound = true, + .upperBound = mc_dec128_from_string("123456789.000000"), + .includeUpperBound = true, + .sparsity = 8, + .min = { .set = true, .value = mc_dec128_from_string("-1000000000000000L") }, + .max = { .set = true, .value = MC_DEC128(0x7000000000000000L) }, + .expectMincoverStrings = { + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000000010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000000011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000000100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000000101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000000110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000000111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000001000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000001001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000001010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000001011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000001100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000001101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000001110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000001111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000010000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000010001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000010010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000010011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000010100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000010101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000010110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000010111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000011000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000011001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000011010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000011011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000011100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000011101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000011110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000011111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000100000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000100001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000100010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000100011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000100100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000100101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000100110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000100111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000101000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000101001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000101010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000101011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000101100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000101101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000101110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000101111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000110000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000110001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000110010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000110011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000110100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000110101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000110110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000110111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000111000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000111001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000111010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000111011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000111100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000111101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000111110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100000111111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001000000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001000010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001000011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001000100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001000101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001000110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001000111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001001000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001001001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001001010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001001011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001001100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001001101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001001110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001001111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001010000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001010001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001010010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001010011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001010100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001010101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001010110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001010111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001011000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001011001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001011010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001011011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001011100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001011101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001011110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001011111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001100000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001100001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001100010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001100011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001100100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001100101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001100110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001100111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001101000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001101001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001101010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001101011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001101100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001101101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001101110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001101111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001110000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001110001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001110010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001110011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001110100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001110101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001110110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001110111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001111000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001111001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001111010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001111011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001111100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001111101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001111110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100001111111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010000000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010000010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010000011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010000100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010000101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010000110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010000111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010001000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010001001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010001010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010001011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010001100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010001101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010001110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010001111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010010000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010010001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010010010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010010011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010010100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010010101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010010110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010010111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010011000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010011001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010011010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010011011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010011100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010011101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010011110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010011111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010100000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010100001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010100010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010100011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010100100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010100101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010100110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010100111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010101000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010101001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010101010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010101011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010101100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010101101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010101110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010101111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010110000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010110001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010110010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010110011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010110100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010110101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010110110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010110111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010111000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010111001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010111010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010111011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010111100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010111101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010111110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100010111111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011000000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011000010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011000011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011000100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011000101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011000110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011000111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011001000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011001001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011001010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011001011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011001100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011001101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011001110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011001111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011010000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011010001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011010010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011010011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011010100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011010101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011010110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011010111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011011000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011011001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011011010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011011011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011011100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011011101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011011110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011011111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011100000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011100001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011100010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011100011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011100100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011100101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011100110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011100111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011101000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011101001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011101010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011101011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011101100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011101101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011101110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011101111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011110000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011110001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011110010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011110011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011110100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011110101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011110110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011110111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011111000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011111001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011111010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011111011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011111100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011111101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011111110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000000000000000001100011111111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000011001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000011010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000011011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000011100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000011101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000011110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000011111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000100000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000100001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000100010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000100011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000100100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000100101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000100110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000100111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000101000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000101001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000101010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000101011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000101100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000101101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000101110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000101111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000110000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000110001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000110010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000110011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000110100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000110101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000110110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000110111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000111000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000111001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000111010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000111011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000111100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000111101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000111110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000000111111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001000000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001000001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001000010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001000011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001000100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001000101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001000110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001000111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001001000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001001001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001001010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001001011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001001100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001001101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001001110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001001111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001010000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001010001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001010010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001010011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001010100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001010101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001010110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001010111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001011000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001011001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001011010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001011011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001011100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001011101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001011110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001011111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001100000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001100001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001100010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001100011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001100100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001100101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001100110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001100111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001101000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001101001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001101010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001101011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001101100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001101101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001101110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001101111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001110000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001110001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001110010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001110011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001110100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001110101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001110110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001110111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001111000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001111001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001111010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001111011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001111100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001111101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001111110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000001111111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010000000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010000001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010000010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010000011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010000100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010000101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010000110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010000111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010001000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010001001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010001010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010001011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010001100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010001101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010001110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010001111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010010000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010010001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010010010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010010011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010010100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010010101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010010110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010010111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010011000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010011001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010011010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010011011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010011100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010011101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010011110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010011111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010100000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010100001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010100010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010100011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010100100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010100101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010100110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010100111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010101000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010101001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010101010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010101011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010101100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010101101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010101110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010101111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010110000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010110001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010110010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010110011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010110100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010110101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010110110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010110111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010111000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010111001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010111010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010111011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010111100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010111101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010111110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000010111111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011000000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011000001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011000010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011000011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011000100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011000101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011000110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011000111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011001000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011001001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011001010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011001011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011001100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011001101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011001110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011001111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011010000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011010001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011010010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011010011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011010100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011010101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011010110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011010111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011011000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011011001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011011010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011011011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011011100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011011101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011011110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011011111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011100000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011100001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011100010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011100011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011100100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011100101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011100110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011100111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011101000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011101001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011101010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011101011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011101100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011101101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011101110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011101111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011110000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011110001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011110010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011110011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011110100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011110101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011110110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011110111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011111000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011111001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011111010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011111011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011111100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011111101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011111110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010010000000000000000011111111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000000001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000000010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000000011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000000100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000000101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000000110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000000111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000001000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000001001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000001010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000001011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000001100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000001101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000001110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000001111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000010000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000010001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000010010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000010011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000010100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000010101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000010110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000010111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000011000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000011001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000011010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000011011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000011100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000011101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000011110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000011111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000100000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000100001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000100010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000100011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000100100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000100101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000100110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000100111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000101000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000101001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000101010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000101011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000101100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000101101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000101110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000101111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000110000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000110001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000110010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000110011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000110100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000110101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000110110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000110111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000111000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000111001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000111010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000111011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000111100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000111101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000111110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000000111111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001000000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001000001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001000010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001000011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001000100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001000101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001000110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001000111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001001000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001001001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001001010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001001011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001001100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001001101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001001110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001001111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001010000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001010001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001010010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001010011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001010100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001010101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001010110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001010111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001011000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001011001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001011010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001011011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001011100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001011101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001011110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001011111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001100000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001100001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001100010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001100011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001100100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001100101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001100110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001100111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001101000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001101001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001101010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001101011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001101100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001101101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001101110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001101111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001110000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001110001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001110010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001110011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001110100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001110101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001110110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001110111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001111000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001111001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001111010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001111011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001111100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001111101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001111110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000001111111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010000000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010000001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010000010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010000011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010000100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010000101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010000110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010000111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010001000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010001001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010001010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010001011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010001100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010001101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010001110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010001111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010010000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010010001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010010010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010010011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010010100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010010101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010010110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010010111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010011000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010011001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010011010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010011011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010011100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010011101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010011110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010011111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010100000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010100001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010100010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010100011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010100100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010100101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010100110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010100111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010101000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010101001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010101010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010101011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010101100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010101101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010101110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010101111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010110000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010110001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010110010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010110011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010110100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010110101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010110110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010110111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010111000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010111001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010111010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010111011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010111100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010111101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010111110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000010111111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011000000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011000001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011000010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011000011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011000100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011000101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011000110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011000111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011001000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011001001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011001010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011001011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011001100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011001101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011001110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011001111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011010000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011010001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011010010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011010011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011010100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011010101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011010110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011010111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011011000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011011001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011011010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011011011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011011100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011011101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011011110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011011111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011100000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011100001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011100010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011100011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011100100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011100101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011100110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011100111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011101000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011101001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011101010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011101011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011101100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011101101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011101110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011101111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011110000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011110001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011110010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011110011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011110100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011110101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011110110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011110111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011111000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011111001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011111010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011111011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011111100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011111101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011111110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110110100100100000000011111111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000000111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000001000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000001001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000001010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000001011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000001100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000001101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000001110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000001111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000010000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000010001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000010010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000010011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000010100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000010101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000010110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000010111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000011000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000011001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000011010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000011011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000011100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000011101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000011110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000011111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000100000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000100001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000100010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000100011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000100100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000100101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000100110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000100111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000101000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000101001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000101010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000101011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000101100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000101101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000101110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000101111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000110000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000110001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000110010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000110011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000110100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000110101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000110110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000110111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000111000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000111001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000111010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000111011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000111100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000111101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000111110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001000111111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001000000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001000010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001000011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001000100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001000101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001000110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001000111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001001000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001001001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001001010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001001011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001001100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001001101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001001110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001001111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001010000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001010001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001010010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001010011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001010100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001010101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001010110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001010111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001011000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001011001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001011010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001011011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001011100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001011101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001011110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001011111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001100000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001100001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001100010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001100011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001100100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001100101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001100110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001100111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001101000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001101001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001101010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001101011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001101100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001101101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001101110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001101111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001110000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001110001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001110010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001110011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001110100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001110101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001110110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001110111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001111000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001111001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001111010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001111011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001111100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001111101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001111110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001001111111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010000000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010000010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010000011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010000100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010000101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010000110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010000111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010001000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010001001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010001010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010001011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010001100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010001101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010001110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010001111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010010000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010010001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010010010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010010011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010010100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010010101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010010110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010010111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010011000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010011001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010011010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010011011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010011100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010011101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010011110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010011111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010100000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010100001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010100010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010100011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010100100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010100101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010100110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010100111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010101000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010101001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010101010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010101011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010101100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010101101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010101110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010101111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010110000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010110001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010110010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010110011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010110100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010110101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010110110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010110111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010111000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010111001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010111010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010111011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010111100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010111101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010111110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001010111111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011000000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011000001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011000010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011000011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011000100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011000101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011000110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011000111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011001000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011001001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011001010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011001011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011001100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011001101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011001110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011001111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011010000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011010001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011010010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011010011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011010100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011010101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011010110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011010111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011011000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011011001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011011010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011011011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011011100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011011101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011011110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011011111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011100000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011100001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011100010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011100011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011100100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011100101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011100110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011100111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011101000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011101001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011101010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011101011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011101100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011101101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011101110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011101111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011110000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011110001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011110010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011110011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011110100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011110101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011110110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011110111", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011111000", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011111001", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011111010", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011111011", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011111100", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011111101", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011111110", + "01010001110001001111011111001000001101100101001111100101011101110100101001010111101101101001001011111111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010010111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010011000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010011001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010011010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010011011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010011100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010011101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010011110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010011111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010100000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010100001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010100010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010100011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010100100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010100101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010100110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010100111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010101000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010101001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010101010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010101011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010101100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010101101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010101110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010101111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010110000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010110001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010110010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010110011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010110100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010110101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010110110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010110111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010111000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010111001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010111010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010111011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010111100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010111101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010111110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011010111111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011000000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011000001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011000010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011000011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011000100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011000101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011000110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011000111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011001000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011001001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011001010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011001011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011001100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011001101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011001110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011001111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011010000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011010001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011010010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011010011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011010100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011010101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011010110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011010111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011011000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011011001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011011010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011011011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011011100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011011101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011011110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011011111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011100000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011100001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011100010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011100011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011100100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011100101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011100110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011100111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011101000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011101001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011101010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011101011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011101100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011101101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011101110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011101111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011110000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011110001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011110010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011110011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011110100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011110101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011110110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011110111", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011111000", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011111001", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011111010", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011111011", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011111100", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011111101", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011111110", + "010100011100010011110111110010000011011001010011111001010111011101001010010101111011011011111111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110110111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110111000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110111001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110111010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110111011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110111100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110111101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110111110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011110111111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111000000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111000001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111000010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111000011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111000100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111000101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111000110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111000111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111001000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111001001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111001010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111001011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111001100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111001101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111001110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111001111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111010000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111010001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111010010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111010011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111010100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111010101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111010110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111010111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111011000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111011001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111011010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111011011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111011100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111011101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111011110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111011111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111100000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111100001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111100010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111100011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111100100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111100101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111100110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111100111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111101000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111101001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111101010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111101011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111101100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111101101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111101110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111101111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111110000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111110001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111110010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111110011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111110100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111110101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111110110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111110111", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111111000", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111111001", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111111010", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111111011", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111111100", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111111101", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111111110", + "0101000111000100111101111100100000110110010100111110010101110111010010100101011111111111", + "01010001110001001111011111001000001101100101001111100101011101110100101001011000", + "01010001110001001111011111001000001101100101001111100101011101110100101001011001", + "01010001110001001111011111001000001101100101001111100101011101110100101001011010", + "01010001110001001111011111001000001101100101001111100101011101110100101001011011", + "01010001110001001111011111001000001101100101001111100101011101110100101001011100", + "01010001110001001111011111001000001101100101001111100101011101110100101001011101", + "01010001110001001111011111001000001101100101001111100101011101110100101001011110", + "01010001110001001111011111001000001101100101001111100101011101110100101001011111", + "01010001110001001111011111001000001101100101001111100101011101110100101001100000", + "01010001110001001111011111001000001101100101001111100101011101110100101001100001", + "01010001110001001111011111001000001101100101001111100101011101110100101001100010", + "01010001110001001111011111001000001101100101001111100101011101110100101001100011", + "01010001110001001111011111001000001101100101001111100101011101110100101001100100", + "01010001110001001111011111001000001101100101001111100101011101110100101001100101", + "01010001110001001111011111001000001101100101001111100101011101110100101001100110", + "01010001110001001111011111001000001101100101001111100101011101110100101001100111", + "01010001110001001111011111001000001101100101001111100101011101110100101001101000", + "01010001110001001111011111001000001101100101001111100101011101110100101001101001", + "01010001110001001111011111001000001101100101001111100101011101110100101001101010", + "01010001110001001111011111001000001101100101001111100101011101110100101001101011", + "01010001110001001111011111001000001101100101001111100101011101110100101001101100", + "01010001110001001111011111001000001101100101001111100101011101110100101001101101", + "01010001110001001111011111001000001101100101001111100101011101110100101001101110", + "01010001110001001111011111001000001101100101001111100101011101110100101001101111", + "01010001110001001111011111001000001101100101001111100101011101110100101001110000", + "01010001110001001111011111001000001101100101001111100101011101110100101001110001", + "01010001110001001111011111001000001101100101001111100101011101110100101001110010", + "01010001110001001111011111001000001101100101001111100101011101110100101001110011", + "01010001110001001111011111001000001101100101001111100101011101110100101001110100", + "01010001110001001111011111001000001101100101001111100101011101110100101001110101", + "01010001110001001111011111001000001101100101001111100101011101110100101001110110", + "01010001110001001111011111001000001101100101001111100101011101110100101001110111", + "01010001110001001111011111001000001101100101001111100101011101110100101001111000", + "01010001110001001111011111001000001101100101001111100101011101110100101001111001", + "01010001110001001111011111001000001101100101001111100101011101110100101001111010", + "01010001110001001111011111001000001101100101001111100101011101110100101001111011", + "01010001110001001111011111001000001101100101001111100101011101110100101001111100", + "01010001110001001111011111001000001101100101001111100101011101110100101001111101", + "01010001110001001111011111001000001101100101001111100101011101110100101001111110", + "01010001110001001111011111001000001101100101001111100101011101110100101001111111", + "01010001110001001111011111001000001101100101001111100101011101110100101010000000", + "01010001110001001111011111001000001101100101001111100101011101110100101010000001", + "01010001110001001111011111001000001101100101001111100101011101110100101010000010", + "01010001110001001111011111001000001101100101001111100101011101110100101010000011", + "01010001110001001111011111001000001101100101001111100101011101110100101010000100", + "01010001110001001111011111001000001101100101001111100101011101110100101010000101", + "01010001110001001111011111001000001101100101001111100101011101110100101010000110", + "01010001110001001111011111001000001101100101001111100101011101110100101010000111", + "01010001110001001111011111001000001101100101001111100101011101110100101010001000", + "01010001110001001111011111001000001101100101001111100101011101110100101010001001", + "01010001110001001111011111001000001101100101001111100101011101110100101010001010", + "01010001110001001111011111001000001101100101001111100101011101110100101010001011", + "01010001110001001111011111001000001101100101001111100101011101110100101010001100", + "01010001110001001111011111001000001101100101001111100101011101110100101010001101", + "01010001110001001111011111001000001101100101001111100101011101110100101010001110", + "01010001110001001111011111001000001101100101001111100101011101110100101010001111", + "01010001110001001111011111001000001101100101001111100101011101110100101010010000", + "01010001110001001111011111001000001101100101001111100101011101110100101010010001", + "01010001110001001111011111001000001101100101001111100101011101110100101010010010", + "01010001110001001111011111001000001101100101001111100101011101110100101010010011", + "01010001110001001111011111001000001101100101001111100101011101110100101010010100", + "01010001110001001111011111001000001101100101001111100101011101110100101010010101", + "01010001110001001111011111001000001101100101001111100101011101110100101010010110", + "01010001110001001111011111001000001101100101001111100101011101110100101010010111", + "01010001110001001111011111001000001101100101001111100101011101110100101010011000", + "01010001110001001111011111001000001101100101001111100101011101110100101010011001", + "01010001110001001111011111001000001101100101001111100101011101110100101010011010", + "01010001110001001111011111001000001101100101001111100101011101110100101010011011", + "01010001110001001111011111001000001101100101001111100101011101110100101010011100", + "01010001110001001111011111001000001101100101001111100101011101110100101010011101", + "01010001110001001111011111001000001101100101001111100101011101110100101010011110", + "01010001110001001111011111001000001101100101001111100101011101110100101010011111", + "01010001110001001111011111001000001101100101001111100101011101110100101010100000", + "01010001110001001111011111001000001101100101001111100101011101110100101010100001", + "01010001110001001111011111001000001101100101001111100101011101110100101010100010", + "01010001110001001111011111001000001101100101001111100101011101110100101010100011", + "01010001110001001111011111001000001101100101001111100101011101110100101010100100", + "01010001110001001111011111001000001101100101001111100101011101110100101010100101", + "01010001110001001111011111001000001101100101001111100101011101110100101010100110", + "01010001110001001111011111001000001101100101001111100101011101110100101010100111", + "01010001110001001111011111001000001101100101001111100101011101110100101010101000", + "01010001110001001111011111001000001101100101001111100101011101110100101010101001", + "01010001110001001111011111001000001101100101001111100101011101110100101010101010", + "01010001110001001111011111001000001101100101001111100101011101110100101010101011", + "01010001110001001111011111001000001101100101001111100101011101110100101010101100", + "01010001110001001111011111001000001101100101001111100101011101110100101010101101", + "01010001110001001111011111001000001101100101001111100101011101110100101010101110", + "01010001110001001111011111001000001101100101001111100101011101110100101010101111", + "01010001110001001111011111001000001101100101001111100101011101110100101010110000", + "01010001110001001111011111001000001101100101001111100101011101110100101010110001", + "01010001110001001111011111001000001101100101001111100101011101110100101010110010", + "01010001110001001111011111001000001101100101001111100101011101110100101010110011", + "01010001110001001111011111001000001101100101001111100101011101110100101010110100", + "01010001110001001111011111001000001101100101001111100101011101110100101010110101", + "01010001110001001111011111001000001101100101001111100101011101110100101010110110", + "01010001110001001111011111001000001101100101001111100101011101110100101010110111", + "01010001110001001111011111001000001101100101001111100101011101110100101010111000", + "01010001110001001111011111001000001101100101001111100101011101110100101010111001", + "01010001110001001111011111001000001101100101001111100101011101110100101010111010", + "01010001110001001111011111001000001101100101001111100101011101110100101010111011", + "01010001110001001111011111001000001101100101001111100101011101110100101010111100", + "01010001110001001111011111001000001101100101001111100101011101110100101010111101", + "01010001110001001111011111001000001101100101001111100101011101110100101010111110", + "01010001110001001111011111001000001101100101001111100101011101110100101010111111", + "01010001110001001111011111001000001101100101001111100101011101110100101011000000", + "01010001110001001111011111001000001101100101001111100101011101110100101011000001", + "01010001110001001111011111001000001101100101001111100101011101110100101011000010", + "01010001110001001111011111001000001101100101001111100101011101110100101011000011", + "01010001110001001111011111001000001101100101001111100101011101110100101011000100", + "01010001110001001111011111001000001101100101001111100101011101110100101011000101", + "01010001110001001111011111001000001101100101001111100101011101110100101011000110", + "01010001110001001111011111001000001101100101001111100101011101110100101011000111", + "01010001110001001111011111001000001101100101001111100101011101110100101011001000", + "01010001110001001111011111001000001101100101001111100101011101110100101011001001", + "01010001110001001111011111001000001101100101001111100101011101110100101011001010", + "01010001110001001111011111001000001101100101001111100101011101110100101011001011", + "01010001110001001111011111001000001101100101001111100101011101110100101011001100", + "01010001110001001111011111001000001101100101001111100101011101110100101011001101", + "01010001110001001111011111001000001101100101001111100101011101110100101011001110", + "01010001110001001111011111001000001101100101001111100101011101110100101011001111", + "01010001110001001111011111001000001101100101001111100101011101110100101011010000", + "01010001110001001111011111001000001101100101001111100101011101110100101011010001", + "01010001110001001111011111001000001101100101001111100101011101110100101011010010", + "01010001110001001111011111001000001101100101001111100101011101110100101011010011", + "01010001110001001111011111001000001101100101001111100101011101110100101011010100", + "01010001110001001111011111001000001101100101001111100101011101110100101011010101", + "01010001110001001111011111001000001101100101001111100101011101110100101011010110", + "01010001110001001111011111001000001101100101001111100101011101110100101011010111", + "01010001110001001111011111001000001101100101001111100101011101110100101011011000", + "01010001110001001111011111001000001101100101001111100101011101110100101011011001", + "01010001110001001111011111001000001101100101001111100101011101110100101011011010", + "01010001110001001111011111001000001101100101001111100101011101110100101011011011", + "01010001110001001111011111001000001101100101001111100101011101110100101011011100", + "01010001110001001111011111001000001101100101001111100101011101110100101011011101", + "01010001110001001111011111001000001101100101001111100101011101110100101011011110", + "01010001110001001111011111001000001101100101001111100101011101110100101011011111", + "01010001110001001111011111001000001101100101001111100101011101110100101011100000", + "01010001110001001111011111001000001101100101001111100101011101110100101011100001", + "01010001110001001111011111001000001101100101001111100101011101110100101011100010", + "01010001110001001111011111001000001101100101001111100101011101110100101011100011", + "01010001110001001111011111001000001101100101001111100101011101110100101011100100", + "01010001110001001111011111001000001101100101001111100101011101110100101011100101", + "01010001110001001111011111001000001101100101001111100101011101110100101011100110", + "01010001110001001111011111001000001101100101001111100101011101110100101011100111", + "01010001110001001111011111001000001101100101001111100101011101110100101011101000", + "01010001110001001111011111001000001101100101001111100101011101110100101011101001", + "01010001110001001111011111001000001101100101001111100101011101110100101011101010", + "01010001110001001111011111001000001101100101001111100101011101110100101011101011", + "01010001110001001111011111001000001101100101001111100101011101110100101011101100", + "01010001110001001111011111001000001101100101001111100101011101110100101011101101", + "01010001110001001111011111001000001101100101001111100101011101110100101011101110", + "01010001110001001111011111001000001101100101001111100101011101110100101011101111", + "01010001110001001111011111001000001101100101001111100101011101110100101011110000", + "01010001110001001111011111001000001101100101001111100101011101110100101011110001", + "01010001110001001111011111001000001101100101001111100101011101110100101011110010", + "01010001110001001111011111001000001101100101001111100101011101110100101011110011", + "01010001110001001111011111001000001101100101001111100101011101110100101011110100", + "01010001110001001111011111001000001101100101001111100101011101110100101011110101", + "01010001110001001111011111001000001101100101001111100101011101110100101011110110", + "01010001110001001111011111001000001101100101001111100101011101110100101011110111", + "01010001110001001111011111001000001101100101001111100101011101110100101011111000", + "01010001110001001111011111001000001101100101001111100101011101110100101011111001", + "01010001110001001111011111001000001101100101001111100101011101110100101011111010", + "01010001110001001111011111001000001101100101001111100101011101110100101011111011", + "01010001110001001111011111001000001101100101001111100101011101110100101011111100", + "01010001110001001111011111001000001101100101001111100101011101110100101011111101", + "01010001110001001111011111001000001101100101001111100101011101110100101011111110", + "01010001110001001111011111001000001101100101001111100101011101110100101011111111", + "010100011100010011110111110010000011011001010011111001010111011101001011", + "010100011100010011110111110010000011011001010011111001010111011101001100", + "010100011100010011110111110010000011011001010011111001010111011101001101", + "010100011100010011110111110010000011011001010011111001010111011101001110", + "010100011100010011110111110010000011011001010011111001010111011101001111", + "010100011100010011110111110010000011011001010011111001010111011101010000", + "010100011100010011110111110010000011011001010011111001010111011101010001", + "010100011100010011110111110010000011011001010011111001010111011101010010", + "010100011100010011110111110010000011011001010011111001010111011101010011", + "010100011100010011110111110010000011011001010011111001010111011101010100", + "010100011100010011110111110010000011011001010011111001010111011101010101", + "010100011100010011110111110010000011011001010011111001010111011101010110", + "010100011100010011110111110010000011011001010011111001010111011101010111", + "010100011100010011110111110010000011011001010011111001010111011101011000", + "010100011100010011110111110010000011011001010011111001010111011101011001", + "010100011100010011110111110010000011011001010011111001010111011101011010", + "010100011100010011110111110010000011011001010011111001010111011101011011", + "010100011100010011110111110010000011011001010011111001010111011101011100", + "010100011100010011110111110010000011011001010011111001010111011101011101", + "010100011100010011110111110010000011011001010011111001010111011101011110", + "010100011100010011110111110010000011011001010011111001010111011101011111", + "010100011100010011110111110010000011011001010011111001010111011101100000", + "010100011100010011110111110010000011011001010011111001010111011101100001", + "010100011100010011110111110010000011011001010011111001010111011101100010", + "010100011100010011110111110010000011011001010011111001010111011101100011", + "010100011100010011110111110010000011011001010011111001010111011101100100", + "010100011100010011110111110010000011011001010011111001010111011101100101", + "010100011100010011110111110010000011011001010011111001010111011101100110", + "010100011100010011110111110010000011011001010011111001010111011101100111", + "010100011100010011110111110010000011011001010011111001010111011101101000", + "010100011100010011110111110010000011011001010011111001010111011101101001", + "010100011100010011110111110010000011011001010011111001010111011101101010", + "010100011100010011110111110010000011011001010011111001010111011101101011", + "010100011100010011110111110010000011011001010011111001010111011101101100", + "010100011100010011110111110010000011011001010011111001010111011101101101", + "010100011100010011110111110010000011011001010011111001010111011101101110", + "010100011100010011110111110010000011011001010011111001010111011101101111", + "010100011100010011110111110010000011011001010011111001010111011101110000", + "010100011100010011110111110010000011011001010011111001010111011101110001", + "010100011100010011110111110010000011011001010011111001010111011101110010", + "010100011100010011110111110010000011011001010011111001010111011101110011", + "010100011100010011110111110010000011011001010011111001010111011101110100", + "010100011100010011110111110010000011011001010011111001010111011101110101", + "010100011100010011110111110010000011011001010011111001010111011101110110", + "010100011100010011110111110010000011011001010011111001010111011101110111", + "010100011100010011110111110010000011011001010011111001010111011101111000", + "010100011100010011110111110010000011011001010011111001010111011101111001", + "010100011100010011110111110010000011011001010011111001010111011101111010", + "010100011100010011110111110010000011011001010011111001010111011101111011", + "010100011100010011110111110010000011011001010011111001010111011101111100", + "010100011100010011110111110010000011011001010011111001010111011101111101", + "010100011100010011110111110010000011011001010011111001010111011101111110", + "010100011100010011110111110010000011011001010011111001010111011101111111", + "010100011100010011110111110010000011011001010011111001010111011110000000", + "010100011100010011110111110010000011011001010011111001010111011110000001", + "010100011100010011110111110010000011011001010011111001010111011110000010", + "010100011100010011110111110010000011011001010011111001010111011110000011", + "010100011100010011110111110010000011011001010011111001010111011110000100", + "010100011100010011110111110010000011011001010011111001010111011110000101", + "010100011100010011110111110010000011011001010011111001010111011110000110", + "010100011100010011110111110010000011011001010011111001010111011110000111", + "010100011100010011110111110010000011011001010011111001010111011110001000", + "010100011100010011110111110010000011011001010011111001010111011110001001", + "010100011100010011110111110010000011011001010011111001010111011110001010", + "010100011100010011110111110010000011011001010011111001010111011110001011", + "010100011100010011110111110010000011011001010011111001010111011110001100", + "010100011100010011110111110010000011011001010011111001010111011110001101", + "010100011100010011110111110010000011011001010011111001010111011110001110", + "010100011100010011110111110010000011011001010011111001010111011110001111", + "010100011100010011110111110010000011011001010011111001010111011110010000", + "010100011100010011110111110010000011011001010011111001010111011110010001", + "010100011100010011110111110010000011011001010011111001010111011110010010", + "010100011100010011110111110010000011011001010011111001010111011110010011", + "010100011100010011110111110010000011011001010011111001010111011110010100", + "010100011100010011110111110010000011011001010011111001010111011110010101", + "010100011100010011110111110010000011011001010011111001010111011110010110", + "010100011100010011110111110010000011011001010011111001010111011110010111", + "010100011100010011110111110010000011011001010011111001010111011110011000", + "010100011100010011110111110010000011011001010011111001010111011110011001", + "010100011100010011110111110010000011011001010011111001010111011110011010", + "010100011100010011110111110010000011011001010011111001010111011110011011", + "010100011100010011110111110010000011011001010011111001010111011110011100", + "010100011100010011110111110010000011011001010011111001010111011110011101", + "010100011100010011110111110010000011011001010011111001010111011110011110", + "010100011100010011110111110010000011011001010011111001010111011110011111", + "010100011100010011110111110010000011011001010011111001010111011110100000", + "010100011100010011110111110010000011011001010011111001010111011110100001", + "010100011100010011110111110010000011011001010011111001010111011110100010", + "010100011100010011110111110010000011011001010011111001010111011110100011", + "010100011100010011110111110010000011011001010011111001010111011110100100", + "010100011100010011110111110010000011011001010011111001010111011110100101", + "010100011100010011110111110010000011011001010011111001010111011110100110", + "010100011100010011110111110010000011011001010011111001010111011110100111", + "010100011100010011110111110010000011011001010011111001010111011110101000", + "010100011100010011110111110010000011011001010011111001010111011110101001", + "010100011100010011110111110010000011011001010011111001010111011110101010", + "010100011100010011110111110010000011011001010011111001010111011110101011", + "010100011100010011110111110010000011011001010011111001010111011110101100", + "010100011100010011110111110010000011011001010011111001010111011110101101", + "010100011100010011110111110010000011011001010011111001010111011110101110", + "010100011100010011110111110010000011011001010011111001010111011110101111", + "010100011100010011110111110010000011011001010011111001010111011110110000", + "010100011100010011110111110010000011011001010011111001010111011110110001", + "010100011100010011110111110010000011011001010011111001010111011110110010", + "010100011100010011110111110010000011011001010011111001010111011110110011", + "010100011100010011110111110010000011011001010011111001010111011110110100", + "010100011100010011110111110010000011011001010011111001010111011110110101", + "010100011100010011110111110010000011011001010011111001010111011110110110", + "010100011100010011110111110010000011011001010011111001010111011110110111", + "010100011100010011110111110010000011011001010011111001010111011110111000", + "010100011100010011110111110010000011011001010011111001010111011110111001", + "010100011100010011110111110010000011011001010011111001010111011110111010", + "010100011100010011110111110010000011011001010011111001010111011110111011", + "010100011100010011110111110010000011011001010011111001010111011110111100", + "010100011100010011110111110010000011011001010011111001010111011110111101", + "010100011100010011110111110010000011011001010011111001010111011110111110", + "010100011100010011110111110010000011011001010011111001010111011110111111", + "010100011100010011110111110010000011011001010011111001010111011111000000", + "010100011100010011110111110010000011011001010011111001010111011111000001", + "010100011100010011110111110010000011011001010011111001010111011111000010", + "010100011100010011110111110010000011011001010011111001010111011111000011", + "010100011100010011110111110010000011011001010011111001010111011111000100", + "010100011100010011110111110010000011011001010011111001010111011111000101", + "010100011100010011110111110010000011011001010011111001010111011111000110", + "010100011100010011110111110010000011011001010011111001010111011111000111", + "010100011100010011110111110010000011011001010011111001010111011111001000", + "010100011100010011110111110010000011011001010011111001010111011111001001", + "010100011100010011110111110010000011011001010011111001010111011111001010", + "010100011100010011110111110010000011011001010011111001010111011111001011", + "010100011100010011110111110010000011011001010011111001010111011111001100", + "010100011100010011110111110010000011011001010011111001010111011111001101", + "010100011100010011110111110010000011011001010011111001010111011111001110", + "010100011100010011110111110010000011011001010011111001010111011111001111", + "010100011100010011110111110010000011011001010011111001010111011111010000", + "010100011100010011110111110010000011011001010011111001010111011111010001", + "010100011100010011110111110010000011011001010011111001010111011111010010", + "010100011100010011110111110010000011011001010011111001010111011111010011", + "010100011100010011110111110010000011011001010011111001010111011111010100", + "010100011100010011110111110010000011011001010011111001010111011111010101", + "010100011100010011110111110010000011011001010011111001010111011111010110", + "010100011100010011110111110010000011011001010011111001010111011111010111", + "010100011100010011110111110010000011011001010011111001010111011111011000", + "010100011100010011110111110010000011011001010011111001010111011111011001", + "010100011100010011110111110010000011011001010011111001010111011111011010", + "010100011100010011110111110010000011011001010011111001010111011111011011", + "010100011100010011110111110010000011011001010011111001010111011111011100", + "010100011100010011110111110010000011011001010011111001010111011111011101", + "010100011100010011110111110010000011011001010011111001010111011111011110", + "010100011100010011110111110010000011011001010011111001010111011111011111", + "010100011100010011110111110010000011011001010011111001010111011111100000", + "010100011100010011110111110010000011011001010011111001010111011111100001", + "010100011100010011110111110010000011011001010011111001010111011111100010", + "010100011100010011110111110010000011011001010011111001010111011111100011", + "010100011100010011110111110010000011011001010011111001010111011111100100", + "010100011100010011110111110010000011011001010011111001010111011111100101", + "010100011100010011110111110010000011011001010011111001010111011111100110", + "010100011100010011110111110010000011011001010011111001010111011111100111", + "010100011100010011110111110010000011011001010011111001010111011111101000", + "010100011100010011110111110010000011011001010011111001010111011111101001", + "010100011100010011110111110010000011011001010011111001010111011111101010", + "010100011100010011110111110010000011011001010011111001010111011111101011", + "010100011100010011110111110010000011011001010011111001010111011111101100", + "010100011100010011110111110010000011011001010011111001010111011111101101", + "010100011100010011110111110010000011011001010011111001010111011111101110", + "010100011100010011110111110010000011011001010011111001010111011111101111", + "010100011100010011110111110010000011011001010011111001010111011111110000", + "010100011100010011110111110010000011011001010011111001010111011111110001", + "010100011100010011110111110010000011011001010011111001010111011111110010", + "010100011100010011110111110010000011011001010011111001010111011111110011", + "010100011100010011110111110010000011011001010011111001010111011111110100", + "010100011100010011110111110010000011011001010011111001010111011111110101", + "010100011100010011110111110010000011011001010011111001010111011111110110", + "010100011100010011110111110010000011011001010011111001010111011111110111", + "010100011100010011110111110010000011011001010011111001010111011111111000", + "010100011100010011110111110010000011011001010011111001010111011111111001", + "010100011100010011110111110010000011011001010011111001010111011111111010", + "010100011100010011110111110010000011011001010011111001010111011111111011", + "010100011100010011110111110010000011011001010011111001010111011111111100", + "010100011100010011110111110010000011011001010011111001010111011111111101", + "010100011100010011110111110010000011011001010011111001010111011111111110", + "010100011100010011110111110010000011011001010011111001010111011111111111", + "0101000111000100111101111100100000110110010100111110010101111000", + "0101000111000100111101111100100000110110010100111110010101111001", + "0101000111000100111101111100100000110110010100111110010101111010", + "0101000111000100111101111100100000110110010100111110010101111011", + "0101000111000100111101111100100000110110010100111110010101111100", + "0101000111000100111101111100100000110110010100111110010101111101", + "0101000111000100111101111100100000110110010100111110010101111110", + "0101000111000100111101111100100000110110010100111110010101111111", + "0101000111000100111101111100100000110110010100111110010110000000", + "0101000111000100111101111100100000110110010100111110010110000001", + "0101000111000100111101111100100000110110010100111110010110000010", + "0101000111000100111101111100100000110110010100111110010110000011", + "0101000111000100111101111100100000110110010100111110010110000100", + "0101000111000100111101111100100000110110010100111110010110000101", + "0101000111000100111101111100100000110110010100111110010110000110", + "0101000111000100111101111100100000110110010100111110010110000111", + "0101000111000100111101111100100000110110010100111110010110001000", + "0101000111000100111101111100100000110110010100111110010110001001", + "0101000111000100111101111100100000110110010100111110010110001010", + "0101000111000100111101111100100000110110010100111110010110001011", + "0101000111000100111101111100100000110110010100111110010110001100", + "0101000111000100111101111100100000110110010100111110010110001101", + "0101000111000100111101111100100000110110010100111110010110001110", + "0101000111000100111101111100100000110110010100111110010110001111", + "0101000111000100111101111100100000110110010100111110010110010000", + "0101000111000100111101111100100000110110010100111110010110010001", + "0101000111000100111101111100100000110110010100111110010110010010", + "0101000111000100111101111100100000110110010100111110010110010011", + "0101000111000100111101111100100000110110010100111110010110010100", + "0101000111000100111101111100100000110110010100111110010110010101", + "0101000111000100111101111100100000110110010100111110010110010110", + "0101000111000100111101111100100000110110010100111110010110010111", + "0101000111000100111101111100100000110110010100111110010110011000", + "0101000111000100111101111100100000110110010100111110010110011001", + "0101000111000100111101111100100000110110010100111110010110011010", + "0101000111000100111101111100100000110110010100111110010110011011", + "0101000111000100111101111100100000110110010100111110010110011100", + "0101000111000100111101111100100000110110010100111110010110011101", + "0101000111000100111101111100100000110110010100111110010110011110", + "0101000111000100111101111100100000110110010100111110010110011111", + "0101000111000100111101111100100000110110010100111110010110100000", + "0101000111000100111101111100100000110110010100111110010110100001", + "0101000111000100111101111100100000110110010100111110010110100010", + "0101000111000100111101111100100000110110010100111110010110100011", + "0101000111000100111101111100100000110110010100111110010110100100", + "0101000111000100111101111100100000110110010100111110010110100101", + "0101000111000100111101111100100000110110010100111110010110100110", + "0101000111000100111101111100100000110110010100111110010110100111", + "0101000111000100111101111100100000110110010100111110010110101000", + "0101000111000100111101111100100000110110010100111110010110101001", + "0101000111000100111101111100100000110110010100111110010110101010", + "0101000111000100111101111100100000110110010100111110010110101011", + "0101000111000100111101111100100000110110010100111110010110101100", + "0101000111000100111101111100100000110110010100111110010110101101", + "0101000111000100111101111100100000110110010100111110010110101110", + "0101000111000100111101111100100000110110010100111110010110101111", + "0101000111000100111101111100100000110110010100111110010110110000", + "0101000111000100111101111100100000110110010100111110010110110001", + "0101000111000100111101111100100000110110010100111110010110110010", + "0101000111000100111101111100100000110110010100111110010110110011", + "0101000111000100111101111100100000110110010100111110010110110100", + "0101000111000100111101111100100000110110010100111110010110110101", + "0101000111000100111101111100100000110110010100111110010110110110", + "0101000111000100111101111100100000110110010100111110010110110111", + "0101000111000100111101111100100000110110010100111110010110111000", + "0101000111000100111101111100100000110110010100111110010110111001", + "0101000111000100111101111100100000110110010100111110010110111010", + "0101000111000100111101111100100000110110010100111110010110111011", + "0101000111000100111101111100100000110110010100111110010110111100", + "0101000111000100111101111100100000110110010100111110010110111101", + "0101000111000100111101111100100000110110010100111110010110111110", + "0101000111000100111101111100100000110110010100111110010110111111", + "0101000111000100111101111100100000110110010100111110010111000000", + "0101000111000100111101111100100000110110010100111110010111000001", + "0101000111000100111101111100100000110110010100111110010111000010", + "0101000111000100111101111100100000110110010100111110010111000011", + "0101000111000100111101111100100000110110010100111110010111000100", + "0101000111000100111101111100100000110110010100111110010111000101", + "0101000111000100111101111100100000110110010100111110010111000110", + "0101000111000100111101111100100000110110010100111110010111000111", + "0101000111000100111101111100100000110110010100111110010111001000", + "0101000111000100111101111100100000110110010100111110010111001001", + "0101000111000100111101111100100000110110010100111110010111001010", + "0101000111000100111101111100100000110110010100111110010111001011", + "0101000111000100111101111100100000110110010100111110010111001100", + "0101000111000100111101111100100000110110010100111110010111001101", + "0101000111000100111101111100100000110110010100111110010111001110", + "0101000111000100111101111100100000110110010100111110010111001111", + "0101000111000100111101111100100000110110010100111110010111010000", + "0101000111000100111101111100100000110110010100111110010111010001", + "0101000111000100111101111100100000110110010100111110010111010010", + "0101000111000100111101111100100000110110010100111110010111010011", + "0101000111000100111101111100100000110110010100111110010111010100", + "0101000111000100111101111100100000110110010100111110010111010101", + "0101000111000100111101111100100000110110010100111110010111010110", + "0101000111000100111101111100100000110110010100111110010111010111", + "0101000111000100111101111100100000110110010100111110010111011000", + "0101000111000100111101111100100000110110010100111110010111011001", + "0101000111000100111101111100100000110110010100111110010111011010", + "0101000111000100111101111100100000110110010100111110010111011011", + "0101000111000100111101111100100000110110010100111110010111011100", + "0101000111000100111101111100100000110110010100111110010111011101", + "0101000111000100111101111100100000110110010100111110010111011110", + "0101000111000100111101111100100000110110010100111110010111011111", + "0101000111000100111101111100100000110110010100111110010111100000", + "0101000111000100111101111100100000110110010100111110010111100001", + "0101000111000100111101111100100000110110010100111110010111100010", + "0101000111000100111101111100100000110110010100111110010111100011", + "0101000111000100111101111100100000110110010100111110010111100100", + "0101000111000100111101111100100000110110010100111110010111100101", + "0101000111000100111101111100100000110110010100111110010111100110", + "0101000111000100111101111100100000110110010100111110010111100111", + "0101000111000100111101111100100000110110010100111110010111101000", + "0101000111000100111101111100100000110110010100111110010111101001", + "0101000111000100111101111100100000110110010100111110010111101010", + "0101000111000100111101111100100000110110010100111110010111101011", + "0101000111000100111101111100100000110110010100111110010111101100", + "0101000111000100111101111100100000110110010100111110010111101101", + "0101000111000100111101111100100000110110010100111110010111101110", + "0101000111000100111101111100100000110110010100111110010111101111", + "0101000111000100111101111100100000110110010100111110010111110000", + "0101000111000100111101111100100000110110010100111110010111110001", + "0101000111000100111101111100100000110110010100111110010111110010", + "0101000111000100111101111100100000110110010100111110010111110011", + "0101000111000100111101111100100000110110010100111110010111110100", + "0101000111000100111101111100100000110110010100111110010111110101", + "0101000111000100111101111100100000110110010100111110010111110110", + "0101000111000100111101111100100000110110010100111110010111110111", + "0101000111000100111101111100100000110110010100111110010111111000", + "0101000111000100111101111100100000110110010100111110010111111001", + "0101000111000100111101111100100000110110010100111110010111111010", + "0101000111000100111101111100100000110110010100111110010111111011", + "0101000111000100111101111100100000110110010100111110010111111100", + "0101000111000100111101111100100000110110010100111110010111111101", + "0101000111000100111101111100100000110110010100111110010111111110", + "0101000111000100111101111100100000110110010100111110010111111111", + "01010001110001001111011111001000001101100101001111100110", + "01010001110001001111011111001000001101100101001111100111", + "01010001110001001111011111001000001101100101001111101000", + "01010001110001001111011111001000001101100101001111101001", + "01010001110001001111011111001000001101100101001111101010", + "01010001110001001111011111001000001101100101001111101011", + "01010001110001001111011111001000001101100101001111101100", + "01010001110001001111011111001000001101100101001111101101", + "01010001110001001111011111001000001101100101001111101110", + "01010001110001001111011111001000001101100101001111101111", + "01010001110001001111011111001000001101100101001111110000", + "01010001110001001111011111001000001101100101001111110001", + "01010001110001001111011111001000001101100101001111110010", + "01010001110001001111011111001000001101100101001111110011", + "01010001110001001111011111001000001101100101001111110100", + "01010001110001001111011111001000001101100101001111110101", + "01010001110001001111011111001000001101100101001111110110", + "01010001110001001111011111001000001101100101001111110111", + "01010001110001001111011111001000001101100101001111111000", + "01010001110001001111011111001000001101100101001111111001", + "01010001110001001111011111001000001101100101001111111010", + "01010001110001001111011111001000001101100101001111111011", + "01010001110001001111011111001000001101100101001111111100", + "01010001110001001111011111001000001101100101001111111101", + "01010001110001001111011111001000001101100101001111111110", + "01010001110001001111011111001000001101100101001111111111", + "010100011100010011110111110010000011011001010100", + "010100011100010011110111110010000011011001010101", + "010100011100010011110111110010000011011001010110", + "010100011100010011110111110010000011011001010111", + "010100011100010011110111110010000011011001011000", + "010100011100010011110111110010000011011001011001", + "010100011100010011110111110010000011011001011010", + "010100011100010011110111110010000011011001011011", + "010100011100010011110111110010000011011001011100", + "010100011100010011110111110010000011011001011101", + "010100011100010011110111110010000011011001011110", + "010100011100010011110111110010000011011001011111", + "010100011100010011110111110010000011011001100000", + "010100011100010011110111110010000011011001100001", + "010100011100010011110111110010000011011001100010", + "010100011100010011110111110010000011011001100011", + "010100011100010011110111110010000011011001100100", + "010100011100010011110111110010000011011001100101", + "010100011100010011110111110010000011011001100110", + "010100011100010011110111110010000011011001100111", + "010100011100010011110111110010000011011001101000", + "010100011100010011110111110010000011011001101001", + "010100011100010011110111110010000011011001101010", + "010100011100010011110111110010000011011001101011", + "010100011100010011110111110010000011011001101100", + "010100011100010011110111110010000011011001101101", + "010100011100010011110111110010000011011001101110", + "010100011100010011110111110010000011011001101111", + "010100011100010011110111110010000011011001110000", + "010100011100010011110111110010000011011001110001", + "010100011100010011110111110010000011011001110010", + "010100011100010011110111110010000011011001110011", + "010100011100010011110111110010000011011001110100", + "010100011100010011110111110010000011011001110101", + "010100011100010011110111110010000011011001110110", + "010100011100010011110111110010000011011001110111", + "010100011100010011110111110010000011011001111000", + "010100011100010011110111110010000011011001111001", + "010100011100010011110111110010000011011001111010", + "010100011100010011110111110010000011011001111011", + "010100011100010011110111110010000011011001111100", + "010100011100010011110111110010000011011001111101", + "010100011100010011110111110010000011011001111110", + "010100011100010011110111110010000011011001111111", + "010100011100010011110111110010000011011010000000", + "010100011100010011110111110010000011011010000001", + "010100011100010011110111110010000011011010000010", + "010100011100010011110111110010000011011010000011", + "010100011100010011110111110010000011011010000100", + "010100011100010011110111110010000011011010000101", + "010100011100010011110111110010000011011010000110", + "010100011100010011110111110010000011011010000111", + "010100011100010011110111110010000011011010001000", + "010100011100010011110111110010000011011010001001", + "010100011100010011110111110010000011011010001010", + "010100011100010011110111110010000011011010001011", + "010100011100010011110111110010000011011010001100", + "010100011100010011110111110010000011011010001101", + "010100011100010011110111110010000011011010001110", + "010100011100010011110111110010000011011010001111", + "010100011100010011110111110010000011011010010000", + "010100011100010011110111110010000011011010010001", + "010100011100010011110111110010000011011010010010", + "010100011100010011110111110010000011011010010011", + "010100011100010011110111110010000011011010010100", + "010100011100010011110111110010000011011010010101", + "010100011100010011110111110010000011011010010110", + "010100011100010011110111110010000011011010010111", + "010100011100010011110111110010000011011010011000", + "010100011100010011110111110010000011011010011001", + "010100011100010011110111110010000011011010011010", + "010100011100010011110111110010000011011010011011", + "010100011100010011110111110010000011011010011100", + "010100011100010011110111110010000011011010011101", + "010100011100010011110111110010000011011010011110", + "010100011100010011110111110010000011011010011111", + "010100011100010011110111110010000011011010100000", + "010100011100010011110111110010000011011010100001", + "010100011100010011110111110010000011011010100010", + "010100011100010011110111110010000011011010100011", + "010100011100010011110111110010000011011010100100", + "010100011100010011110111110010000011011010100101", + "010100011100010011110111110010000011011010100110", + "010100011100010011110111110010000011011010100111", + "010100011100010011110111110010000011011010101000", + "010100011100010011110111110010000011011010101001", + "010100011100010011110111110010000011011010101010", + "010100011100010011110111110010000011011010101011", + "010100011100010011110111110010000011011010101100", + "010100011100010011110111110010000011011010101101", + "010100011100010011110111110010000011011010101110", + "010100011100010011110111110010000011011010101111", + "010100011100010011110111110010000011011010110000", + "010100011100010011110111110010000011011010110001", + "010100011100010011110111110010000011011010110010", + "010100011100010011110111110010000011011010110011", + "010100011100010011110111110010000011011010110100", + "010100011100010011110111110010000011011010110101", + "010100011100010011110111110010000011011010110110", + "010100011100010011110111110010000011011010110111", + "010100011100010011110111110010000011011010111000", + "010100011100010011110111110010000011011010111001", + "010100011100010011110111110010000011011010111010", + "010100011100010011110111110010000011011010111011", + "010100011100010011110111110010000011011010111100", + "010100011100010011110111110010000011011010111101", + "010100011100010011110111110010000011011010111110", + "010100011100010011110111110010000011011010111111", + "010100011100010011110111110010000011011011000000", + "010100011100010011110111110010000011011011000001", + "010100011100010011110111110010000011011011000010", + "010100011100010011110111110010000011011011000011", + "010100011100010011110111110010000011011011000100", + "010100011100010011110111110010000011011011000101", + "010100011100010011110111110010000011011011000110", + "010100011100010011110111110010000011011011000111", + "010100011100010011110111110010000011011011001000", + "010100011100010011110111110010000011011011001001", + "010100011100010011110111110010000011011011001010", + "010100011100010011110111110010000011011011001011", + "010100011100010011110111110010000011011011001100", + "010100011100010011110111110010000011011011001101", + "010100011100010011110111110010000011011011001110", + "010100011100010011110111110010000011011011001111", + "010100011100010011110111110010000011011011010000", + "010100011100010011110111110010000011011011010001", + "010100011100010011110111110010000011011011010010", + "010100011100010011110111110010000011011011010011", + "010100011100010011110111110010000011011011010100", + "010100011100010011110111110010000011011011010101", + "010100011100010011110111110010000011011011010110", + "010100011100010011110111110010000011011011010111", + "010100011100010011110111110010000011011011011000", + "010100011100010011110111110010000011011011011001", + "010100011100010011110111110010000011011011011010", + "010100011100010011110111110010000011011011011011", + "010100011100010011110111110010000011011011011100", + "010100011100010011110111110010000011011011011101", + "010100011100010011110111110010000011011011011110", + "010100011100010011110111110010000011011011011111", + "010100011100010011110111110010000011011011100000", + "010100011100010011110111110010000011011011100001", + "010100011100010011110111110010000011011011100010", + "010100011100010011110111110010000011011011100011", + "010100011100010011110111110010000011011011100100", + "010100011100010011110111110010000011011011100101", + "010100011100010011110111110010000011011011100110", + "010100011100010011110111110010000011011011100111", + "010100011100010011110111110010000011011011101000", + "010100011100010011110111110010000011011011101001", + "010100011100010011110111110010000011011011101010", + "010100011100010011110111110010000011011011101011", + "010100011100010011110111110010000011011011101100", + "010100011100010011110111110010000011011011101101", + "010100011100010011110111110010000011011011101110", + "010100011100010011110111110010000011011011101111", + "010100011100010011110111110010000011011011110000", + "010100011100010011110111110010000011011011110001", + "010100011100010011110111110010000011011011110010", + "010100011100010011110111110010000011011011110011", + "010100011100010011110111110010000011011011110100", + "010100011100010011110111110010000011011011110101", + "010100011100010011110111110010000011011011110110", + "010100011100010011110111110010000011011011110111", + "010100011100010011110111110010000011011011111000", + "010100011100010011110111110010000011011011111001", + "010100011100010011110111110010000011011011111010", + "010100011100010011110111110010000011011011111011", + "010100011100010011110111110010000011011011111100", + "010100011100010011110111110010000011011011111101", + "010100011100010011110111110010000011011011111110", + "010100011100010011110111110010000011011011111111", + "0101000111000100111101111100100000110111", + "0101000111000100111101111100100000111000", + "0101000111000100111101111100100000111001", + "0101000111000100111101111100100000111010", + "0101000111000100111101111100100000111011", + "0101000111000100111101111100100000111100", + "0101000111000100111101111100100000111101", + "0101000111000100111101111100100000111110", + "0101000111000100111101111100100000111111", + "0101000111000100111101111100100001000000", + "0101000111000100111101111100100001000001", + "0101000111000100111101111100100001000010", + "0101000111000100111101111100100001000011", + "0101000111000100111101111100100001000100", + "0101000111000100111101111100100001000101", + "0101000111000100111101111100100001000110", + "0101000111000100111101111100100001000111", + "0101000111000100111101111100100001001000", + "0101000111000100111101111100100001001001", + "0101000111000100111101111100100001001010", + "0101000111000100111101111100100001001011", + "0101000111000100111101111100100001001100", + "0101000111000100111101111100100001001101", + "0101000111000100111101111100100001001110", + "0101000111000100111101111100100001001111", + "0101000111000100111101111100100001010000", + "0101000111000100111101111100100001010001", + "0101000111000100111101111100100001010010", + "0101000111000100111101111100100001010011", + "0101000111000100111101111100100001010100", + "0101000111000100111101111100100001010101", + "0101000111000100111101111100100001010110", + "0101000111000100111101111100100001010111", + "0101000111000100111101111100100001011000", + "0101000111000100111101111100100001011001", + "0101000111000100111101111100100001011010", + "0101000111000100111101111100100001011011", + "0101000111000100111101111100100001011100", + "0101000111000100111101111100100001011101", + "0101000111000100111101111100100001011110", + "0101000111000100111101111100100001011111", + "0101000111000100111101111100100001100000", + "0101000111000100111101111100100001100001", + "0101000111000100111101111100100001100010", + "0101000111000100111101111100100001100011", + "0101000111000100111101111100100001100100", + "0101000111000100111101111100100001100101", + "0101000111000100111101111100100001100110", + "0101000111000100111101111100100001100111", + "0101000111000100111101111100100001101000", + "0101000111000100111101111100100001101001", + "0101000111000100111101111100100001101010", + "0101000111000100111101111100100001101011", + "0101000111000100111101111100100001101100", + "0101000111000100111101111100100001101101", + "0101000111000100111101111100100001101110", + "0101000111000100111101111100100001101111", + "0101000111000100111101111100100001110000", + "0101000111000100111101111100100001110001", + "0101000111000100111101111100100001110010", + "0101000111000100111101111100100001110011", + "0101000111000100111101111100100001110100", + "0101000111000100111101111100100001110101", + "0101000111000100111101111100100001110110", + "0101000111000100111101111100100001110111", + "0101000111000100111101111100100001111000", + "0101000111000100111101111100100001111001", + "0101000111000100111101111100100001111010", + "0101000111000100111101111100100001111011", + "0101000111000100111101111100100001111100", + "0101000111000100111101111100100001111101", + "0101000111000100111101111100100001111110", + "0101000111000100111101111100100001111111", + "0101000111000100111101111100100010000000", + "0101000111000100111101111100100010000001", + "0101000111000100111101111100100010000010", + "0101000111000100111101111100100010000011", + "0101000111000100111101111100100010000100", + "0101000111000100111101111100100010000101", + "0101000111000100111101111100100010000110", + "0101000111000100111101111100100010000111", + "0101000111000100111101111100100010001000", + "0101000111000100111101111100100010001001", + "0101000111000100111101111100100010001010", + "0101000111000100111101111100100010001011", + "0101000111000100111101111100100010001100", + "0101000111000100111101111100100010001101", + "0101000111000100111101111100100010001110", + "0101000111000100111101111100100010001111", + "0101000111000100111101111100100010010000", + "0101000111000100111101111100100010010001", + "0101000111000100111101111100100010010010", + "0101000111000100111101111100100010010011", + "0101000111000100111101111100100010010100", + "0101000111000100111101111100100010010101", + "0101000111000100111101111100100010010110", + "0101000111000100111101111100100010010111", + "0101000111000100111101111100100010011000", + "0101000111000100111101111100100010011001", + "0101000111000100111101111100100010011010", + "0101000111000100111101111100100010011011", + "0101000111000100111101111100100010011100", + "0101000111000100111101111100100010011101", + "0101000111000100111101111100100010011110", + "0101000111000100111101111100100010011111", + "0101000111000100111101111100100010100000", + "0101000111000100111101111100100010100001", + "0101000111000100111101111100100010100010", + "0101000111000100111101111100100010100011", + "0101000111000100111101111100100010100100", + "0101000111000100111101111100100010100101", + "0101000111000100111101111100100010100110", + "0101000111000100111101111100100010100111", + "0101000111000100111101111100100010101000", + "0101000111000100111101111100100010101001", + "0101000111000100111101111100100010101010", + "0101000111000100111101111100100010101011", + "0101000111000100111101111100100010101100", + "0101000111000100111101111100100010101101", + "0101000111000100111101111100100010101110", + "0101000111000100111101111100100010101111", + "0101000111000100111101111100100010110000", + "0101000111000100111101111100100010110001", + "0101000111000100111101111100100010110010", + "0101000111000100111101111100100010110011", + "0101000111000100111101111100100010110100", + "0101000111000100111101111100100010110101", + "0101000111000100111101111100100010110110", + "0101000111000100111101111100100010110111", + "0101000111000100111101111100100010111000", + "0101000111000100111101111100100010111001", + "0101000111000100111101111100100010111010", + "0101000111000100111101111100100010111011", + "0101000111000100111101111100100010111100", + "0101000111000100111101111100100010111101", + "0101000111000100111101111100100010111110", + "0101000111000100111101111100100010111111", + "0101000111000100111101111100100011000000", + "0101000111000100111101111100100011000001", + "0101000111000100111101111100100011000010", + "0101000111000100111101111100100011000011", + "0101000111000100111101111100100011000100", + "0101000111000100111101111100100011000101", + "0101000111000100111101111100100011000110", + "0101000111000100111101111100100011000111", + "0101000111000100111101111100100011001000", + "0101000111000100111101111100100011001001", + "0101000111000100111101111100100011001010", + "0101000111000100111101111100100011001011", + "0101000111000100111101111100100011001100", + "0101000111000100111101111100100011001101", + "0101000111000100111101111100100011001110", + "0101000111000100111101111100100011001111", + "0101000111000100111101111100100011010000", + "0101000111000100111101111100100011010001", + "0101000111000100111101111100100011010010", + "0101000111000100111101111100100011010011", + "0101000111000100111101111100100011010100", + "0101000111000100111101111100100011010101", + "0101000111000100111101111100100011010110", + "0101000111000100111101111100100011010111", + "0101000111000100111101111100100011011000", + "0101000111000100111101111100100011011001", + "0101000111000100111101111100100011011010", + "0101000111000100111101111100100011011011", + "0101000111000100111101111100100011011100", + "0101000111000100111101111100100011011101", + "0101000111000100111101111100100011011110", + "0101000111000100111101111100100011011111", + "0101000111000100111101111100100011100000", + "0101000111000100111101111100100011100001", + "0101000111000100111101111100100011100010", + "0101000111000100111101111100100011100011", + "0101000111000100111101111100100011100100", + "0101000111000100111101111100100011100101", + "0101000111000100111101111100100011100110", + "0101000111000100111101111100100011100111", + "0101000111000100111101111100100011101000", + "0101000111000100111101111100100011101001", + "0101000111000100111101111100100011101010", + "0101000111000100111101111100100011101011", + "0101000111000100111101111100100011101100", + "0101000111000100111101111100100011101101", + "0101000111000100111101111100100011101110", + "0101000111000100111101111100100011101111", + "0101000111000100111101111100100011110000", + "0101000111000100111101111100100011110001", + "0101000111000100111101111100100011110010", + "0101000111000100111101111100100011110011", + "0101000111000100111101111100100011110100", + "0101000111000100111101111100100011110101", + "0101000111000100111101111100100011110110", + "0101000111000100111101111100100011110111", + "0101000111000100111101111100100011111000", + "0101000111000100111101111100100011111001", + "0101000111000100111101111100100011111010", + "0101000111000100111101111100100011111011", + "0101000111000100111101111100100011111100", + "0101000111000100111101111100100011111101", + "0101000111000100111101111100100011111110", + "0101000111000100111101111100100011111111", + "01010001110001001111011111001001", + "01010001110001001111011111001010", + "01010001110001001111011111001011", + "01010001110001001111011111001100", + "01010001110001001111011111001101", + "01010001110001001111011111001110", + "01010001110001001111011111001111", + "01010001110001001111011111010000", + "01010001110001001111011111010001", + "01010001110001001111011111010010", + "01010001110001001111011111010011", + "01010001110001001111011111010100", + "01010001110001001111011111010101", + "01010001110001001111011111010110", + "01010001110001001111011111010111", + "01010001110001001111011111011000", + "01010001110001001111011111011001", + "01010001110001001111011111011010", + "01010001110001001111011111011011", + "01010001110001001111011111011100", + "01010001110001001111011111011101", + "01010001110001001111011111011110", + "01010001110001001111011111011111", + "01010001110001001111011111100000", + "01010001110001001111011111100001", + "01010001110001001111011111100010", + "01010001110001001111011111100011", + "01010001110001001111011111100100", + "01010001110001001111011111100101", + "01010001110001001111011111100110", + "01010001110001001111011111100111", + "01010001110001001111011111101000", + "01010001110001001111011111101001", + "01010001110001001111011111101010", + "01010001110001001111011111101011", + "01010001110001001111011111101100", + "01010001110001001111011111101101", + "01010001110001001111011111101110", + "01010001110001001111011111101111", + "01010001110001001111011111110000", + "01010001110001001111011111110001", + "01010001110001001111011111110010", + "01010001110001001111011111110011", + "01010001110001001111011111110100", + "01010001110001001111011111110101", + "01010001110001001111011111110110", + "01010001110001001111011111110111", + "01010001110001001111011111111000", + "01010001110001001111011111111001", + "01010001110001001111011111111010", + "01010001110001001111011111111011", + "01010001110001001111011111111100", + "01010001110001001111011111111101", + "01010001110001001111011111111110", + "01010001110001001111011111111111", + "010100011100010011111000", + "010100011100010011111001", + "010100011100010011111010", + "010100011100010011111011", + "010100011100010011111100", + "010100011100010011111101", + "010100011100010011111110", + "010100011100010011111111", + "0101000111000101", + "0101000111000110", + "0101000111000111", + "0101000111001000", + "0101000111001001", + "0101000111001010", + "0101000111001011", + "0101000111001100", + "0101000111001101", + "0101000111001110", + "0101000111001111", + "0101000111010000", + "0101000111010001", + "0101000111010010", + "0101000111010011", + "0101000111010100", + "0101000111010101", + "0101000111010110", + "0101000111010111", + "0101000111011000", + "0101000111011001", + "0101000111011010", + "0101000111011011", + "0101000111011100", + "0101000111011101", + "0101000111011110", + "0101000111011111", + "0101000111100000", + "0101000111100001", + "0101000111100010", + "0101000111100011", + "0101000111100100", + "0101000111100101", + "0101000111100110", + "0101000111100111", + "0101000111101000", + "0101000111101001", + "0101000111101010", + "0101000111101011", + "0101000111101100", + "0101000111101101", + "0101000111101110", + "0101000111101111", + "0101000111110000", + "0101000111110001", + "0101000111110010", + "0101000111110011", + "0101000111110100", + "0101000111110101", + "0101000111110110", + "0101000111110111", + "0101000111111000", + "0101000111111001", + "0101000111111010", + "0101000111111011", + "0101000111111100", + "0101000111111101", + "0101000111111110", + "0101000111111111", + "01010010", + "01010011", + "01010100", + "01010101", + "01010110", + "01010111", + "01011000", + "01011001", + "01011010", + "01011011", + "01011100", + "01011101", + "01011110", + "01011111", + "01100000", + "01100001", + "01100010", + "01100011", + "01100100", + "01100101", + "01100110", + "01100111", + "01101000", + "01101001", + "01101010", + "01101011", + "01101100", + "01101101", + "01101110", + "01101111", + "01110000", + "01110001", + "01110010", + "01110011", + "01110100", + "01110101", + "01110110", + "01110111", + "01111000", + "01111001", + "01111010", + "01111011", + "01111100", + "01111101", + "01111110", + "01111111", + "10000000", + "10000001", + "10000010", + "10000011", + "10000100", + "10000101", + "10000110", + "10000111", + "10001000", + "10001001", + "10001010", + "10001011", + "10001100", + "10001101", + "10001110", + "10001111", + "10010000", + "10010001", + "10010010", + "10010011", + "10010100", + "10010101", + "10010110", + "10010111", + "10011000", + "10011001", + "10011010", + "10011011", + "10011100", + "10011101", + "10011110", + "10011111", + "10100000", + "10100001", + "10100010", + "10100011", + "10100100", + "10100101", + "10100110", + "10100111", + "10101000", + "10101001", + "10101010", + "10101011", + "10101100", + "10101101", + "1010111000000000", + "1010111000000001", + "1010111000000010", + "1010111000000011", + "1010111000000100", + "1010111000000101", + "1010111000000110", + "1010111000000111", + "1010111000001000", + "1010111000001001", + "1010111000001010", + "1010111000001011", + "1010111000001100", + "1010111000001101", + "1010111000001110", + "1010111000001111", + "1010111000010000", + "1010111000010001", + "1010111000010010", + "1010111000010011", + "1010111000010100", + "1010111000010101", + "1010111000010110", + "1010111000010111", + "1010111000011000", + "1010111000011001", + "1010111000011010", + "1010111000011011", + "1010111000011100", + "1010111000011101", + "1010111000011110", + "1010111000011111", + "1010111000100000", + "1010111000100001", + "1010111000100010", + "1010111000100011", + "1010111000100100", + "1010111000100101", + "1010111000100110", + "1010111000100111", + "1010111000101000", + "1010111000101001", + "1010111000101010", + "1010111000101011", + "1010111000101100", + "1010111000101101", + "1010111000101110", + "1010111000101111", + "1010111000110000", + "1010111000110001", + "1010111000110010", + "1010111000110011", + "1010111000110100", + "1010111000110101", + "1010111000110110", + "1010111000110111", + "1010111000111000", + "1010111000111001", + "1010111000111010", + "1010111000111011", + "1010111000111100", + "1010111000111101", + "1010111000111110", + "1010111000111111", + "1010111001000000", + "1010111001000001", + "1010111001000010", + "1010111001000011", + "1010111001000100", + "1010111001000101", + "101011100100011000000000", + "101011100100011000000001", + "101011100100011000000010", + "101011100100011000000011", + "101011100100011000000100", + "101011100100011000000101", + "101011100100011000000110", + "101011100100011000000111", + "101011100100011000001000", + "101011100100011000001001", + "101011100100011000001010", + "101011100100011000001011", + "101011100100011000001100", + "101011100100011000001101", + "101011100100011000001110", + "101011100100011000001111", + "101011100100011000010000", + "101011100100011000010001", + "101011100100011000010010", + "101011100100011000010011", + "101011100100011000010100", + "101011100100011000010101", + "101011100100011000010110", + "101011100100011000010111", + "101011100100011000011000", + "101011100100011000011001", + "101011100100011000011010", + "101011100100011000011011", + "101011100100011000011100", + "101011100100011000011101", + "101011100100011000011110", + "101011100100011000011111", + "101011100100011000100000", + "101011100100011000100001", + "101011100100011000100010", + "101011100100011000100011", + "101011100100011000100100", + "101011100100011000100101", + "101011100100011000100110", + "101011100100011000100111", + "101011100100011000101000", + "101011100100011000101001", + "101011100100011000101010", + "101011100100011000101011", + "101011100100011000101100", + "101011100100011000101101", + "101011100100011000101110", + "101011100100011000101111", + "101011100100011000110000", + "101011100100011000110001", + "101011100100011000110010", + "101011100100011000110011", + "101011100100011000110100", + "101011100100011000110101", + "101011100100011000110110", + "101011100100011000110111", + "101011100100011000111000", + "101011100100011000111001", + "101011100100011000111010", + "101011100100011000111011", + "101011100100011000111100", + "101011100100011000111101", + "101011100100011000111110", + "101011100100011000111111", + "101011100100011001000000", + "101011100100011001000001", + "101011100100011001000010", + "101011100100011001000011", + "101011100100011001000100", + "101011100100011001000101", + "101011100100011001000110", + "101011100100011001000111", + "101011100100011001001000", + "101011100100011001001001", + "101011100100011001001010", + "101011100100011001001011", + "101011100100011001001100", + "101011100100011001001101", + "101011100100011001001110", + "101011100100011001001111", + "101011100100011001010000", + "101011100100011001010001", + "101011100100011001010010", + "101011100100011001010011", + "101011100100011001010100", + "101011100100011001010101", + "101011100100011001010110", + "101011100100011001010111", + "101011100100011001011000", + "101011100100011001011001", + "101011100100011001011010", + "101011100100011001011011", + "101011100100011001011100", + "101011100100011001011101", + "101011100100011001011110", + "101011100100011001011111", + "101011100100011001100000", + "101011100100011001100001", + "101011100100011001100010", + "101011100100011001100011", + "101011100100011001100100", + "101011100100011001100101", + "101011100100011001100110", + "101011100100011001100111", + "101011100100011001101000", + "101011100100011001101001", + "101011100100011001101010", + "101011100100011001101011", + "101011100100011001101100", + "101011100100011001101101", + "101011100100011001101110", + "101011100100011001101111", + "101011100100011001110000", + "101011100100011001110001", + "101011100100011001110010", + "101011100100011001110011", + "101011100100011001110100", + "101011100100011001110101", + "101011100100011001110110", + "101011100100011001110111", + "101011100100011001111000", + "101011100100011001111001", + "101011100100011001111010", + "101011100100011001111011", + "101011100100011001111100", + "101011100100011001111101", + "101011100100011001111110", + "101011100100011001111111", + "101011100100011010000000", + "101011100100011010000001", + "101011100100011010000010", + "101011100100011010000011", + "101011100100011010000100", + "101011100100011010000101", + "101011100100011010000110", + "101011100100011010000111", + "101011100100011010001000", + "101011100100011010001001", + "101011100100011010001010", + "101011100100011010001011", + "101011100100011010001100", + "101011100100011010001101", + "101011100100011010001110", + "101011100100011010001111", + "101011100100011010010000", + "101011100100011010010001", + "101011100100011010010010", + "101011100100011010010011", + "101011100100011010010100", + "101011100100011010010101", + "101011100100011010010110", + "101011100100011010010111", + "101011100100011010011000", + "101011100100011010011001", + "101011100100011010011010", + "101011100100011010011011", + "101011100100011010011100", + "101011100100011010011101", + "101011100100011010011110", + "101011100100011010011111", + "101011100100011010100000", + "101011100100011010100001", + "10101110010001101010001000000000", + "10101110010001101010001000000001", + "1010111001000110101000100000001000000000", + "1010111001000110101000100000001000000001", + "1010111001000110101000100000001000000010", + "1010111001000110101000100000001000000011", + "1010111001000110101000100000001000000100", + "1010111001000110101000100000001000000101", + "1010111001000110101000100000001000000110", + "1010111001000110101000100000001000000111", + "1010111001000110101000100000001000001000", + "1010111001000110101000100000001000001001", + "1010111001000110101000100000001000001010", + "1010111001000110101000100000001000001011", + "1010111001000110101000100000001000001100", + "1010111001000110101000100000001000001101", + "1010111001000110101000100000001000001110", + "1010111001000110101000100000001000001111", + "1010111001000110101000100000001000010000", + "1010111001000110101000100000001000010001", + "1010111001000110101000100000001000010010", + "1010111001000110101000100000001000010011", + "1010111001000110101000100000001000010100", + "1010111001000110101000100000001000010101", + "1010111001000110101000100000001000010110", + "1010111001000110101000100000001000010111", + "1010111001000110101000100000001000011000", + "1010111001000110101000100000001000011001", + "1010111001000110101000100000001000011010", + "1010111001000110101000100000001000011011", + "1010111001000110101000100000001000011100", + "1010111001000110101000100000001000011101", + "1010111001000110101000100000001000011110", + "1010111001000110101000100000001000011111", + "1010111001000110101000100000001000100000", + "1010111001000110101000100000001000100001", + "1010111001000110101000100000001000100010", + "1010111001000110101000100000001000100011", + "1010111001000110101000100000001000100100", + "1010111001000110101000100000001000100101", + "1010111001000110101000100000001000100110", + "1010111001000110101000100000001000100111", + "1010111001000110101000100000001000101000", + "1010111001000110101000100000001000101001", + "1010111001000110101000100000001000101010", + "1010111001000110101000100000001000101011", + "1010111001000110101000100000001000101100", + "1010111001000110101000100000001000101101", + "1010111001000110101000100000001000101110", + "1010111001000110101000100000001000101111", + "1010111001000110101000100000001000110000", + "1010111001000110101000100000001000110001", + "1010111001000110101000100000001000110010", + "1010111001000110101000100000001000110011", + "1010111001000110101000100000001000110100", + "1010111001000110101000100000001000110101", + "1010111001000110101000100000001000110110", + "1010111001000110101000100000001000110111", + "1010111001000110101000100000001000111000", + "1010111001000110101000100000001000111001", + "1010111001000110101000100000001000111010", + "1010111001000110101000100000001000111011", + "1010111001000110101000100000001000111100", + "1010111001000110101000100000001000111101", + "1010111001000110101000100000001000111110", + "1010111001000110101000100000001000111111", + "1010111001000110101000100000001001000000", + "1010111001000110101000100000001001000001", + "1010111001000110101000100000001001000010", + "1010111001000110101000100000001001000011", + "1010111001000110101000100000001001000100", + "1010111001000110101000100000001001000101", + "1010111001000110101000100000001001000110", + "1010111001000110101000100000001001000111", + "1010111001000110101000100000001001001000", + "1010111001000110101000100000001001001001", + "1010111001000110101000100000001001001010", + "1010111001000110101000100000001001001011", + "1010111001000110101000100000001001001100", + "1010111001000110101000100000001001001101", + "1010111001000110101000100000001001001110", + "1010111001000110101000100000001001001111", + "1010111001000110101000100000001001010000", + "1010111001000110101000100000001001010001", + "1010111001000110101000100000001001010010", + "1010111001000110101000100000001001010011", + "1010111001000110101000100000001001010100", + "1010111001000110101000100000001001010101", + "1010111001000110101000100000001001010110", + "1010111001000110101000100000001001010111", + "1010111001000110101000100000001001011000", + "1010111001000110101000100000001001011001", + "1010111001000110101000100000001001011010", + "1010111001000110101000100000001001011011", + "1010111001000110101000100000001001011100", + "1010111001000110101000100000001001011101", + "1010111001000110101000100000001001011110", + "1010111001000110101000100000001001011111", + "1010111001000110101000100000001001100000", + "1010111001000110101000100000001001100001", + "1010111001000110101000100000001001100010", + "1010111001000110101000100000001001100011", + "1010111001000110101000100000001001100100", + "1010111001000110101000100000001001100101", + "1010111001000110101000100000001001100110", + "1010111001000110101000100000001001100111", + "1010111001000110101000100000001001101000", + "1010111001000110101000100000001001101001", + "1010111001000110101000100000001001101010", + "1010111001000110101000100000001001101011", + "1010111001000110101000100000001001101100", + "1010111001000110101000100000001001101101", + "1010111001000110101000100000001001101110", + "1010111001000110101000100000001001101111", + "1010111001000110101000100000001001110000", + "1010111001000110101000100000001001110001", + "1010111001000110101000100000001001110010", + "1010111001000110101000100000001001110011", + "1010111001000110101000100000001001110100", + "1010111001000110101000100000001001110101", + "1010111001000110101000100000001001110110", + "1010111001000110101000100000001001110111", + "1010111001000110101000100000001001111000", + "1010111001000110101000100000001001111001", + "1010111001000110101000100000001001111010", + "1010111001000110101000100000001001111011", + "1010111001000110101000100000001001111100", + "1010111001000110101000100000001001111101", + "1010111001000110101000100000001001111110", + "1010111001000110101000100000001001111111", + "1010111001000110101000100000001010000000", + "1010111001000110101000100000001010000001", + "1010111001000110101000100000001010000010", + "1010111001000110101000100000001010000011", + "1010111001000110101000100000001010000100", + "1010111001000110101000100000001010000101", + "1010111001000110101000100000001010000110", + "1010111001000110101000100000001010000111", + "1010111001000110101000100000001010001000", + "1010111001000110101000100000001010001001", + "1010111001000110101000100000001010001010", + "1010111001000110101000100000001010001011", + "1010111001000110101000100000001010001100", + "1010111001000110101000100000001010001101", + "1010111001000110101000100000001010001110", + "1010111001000110101000100000001010001111", + "1010111001000110101000100000001010010000", + "1010111001000110101000100000001010010001", + "1010111001000110101000100000001010010010", + "1010111001000110101000100000001010010011", + "1010111001000110101000100000001010010100", + "1010111001000110101000100000001010010101", + "1010111001000110101000100000001010010110", + "1010111001000110101000100000001010010111", + "1010111001000110101000100000001010011000", + "1010111001000110101000100000001010011001", + "1010111001000110101000100000001010011010", + "1010111001000110101000100000001010011011", + "1010111001000110101000100000001010011100", + "1010111001000110101000100000001010011101", + "1010111001000110101000100000001010011110", + "1010111001000110101000100000001010011111", + "1010111001000110101000100000001010100000", + "1010111001000110101000100000001010100001", + "1010111001000110101000100000001010100010", + "1010111001000110101000100000001010100011", + "1010111001000110101000100000001010100100", + "1010111001000110101000100000001010100101", + "1010111001000110101000100000001010100110", + "1010111001000110101000100000001010100111", + "1010111001000110101000100000001010101000", + "1010111001000110101000100000001010101001", + "1010111001000110101000100000001010101010", + "1010111001000110101000100000001010101011", + "1010111001000110101000100000001010101100", + "1010111001000110101000100000001010101101", + "1010111001000110101000100000001010101110", + "1010111001000110101000100000001010101111", + "1010111001000110101000100000001010110000", + "1010111001000110101000100000001010110001", + "1010111001000110101000100000001010110010", + "1010111001000110101000100000001010110011", + "1010111001000110101000100000001010110100", + "1010111001000110101000100000001010110101", + "1010111001000110101000100000001010110110", + "1010111001000110101000100000001010110111", + "1010111001000110101000100000001010111000", + "1010111001000110101000100000001010111001", + "1010111001000110101000100000001010111010", + "1010111001000110101000100000001010111011", + "1010111001000110101000100000001010111100", + "1010111001000110101000100000001010111101", + "1010111001000110101000100000001010111110", + "1010111001000110101000100000001010111111", + "1010111001000110101000100000001011000000", + "1010111001000110101000100000001011000001", + "1010111001000110101000100000001011000010", + "1010111001000110101000100000001011000011", + "1010111001000110101000100000001011000100", + "1010111001000110101000100000001011000101", + "1010111001000110101000100000001011000110", + "1010111001000110101000100000001011000111", + "1010111001000110101000100000001011001000", + "1010111001000110101000100000001011001001", + "1010111001000110101000100000001011001010", + "1010111001000110101000100000001011001011", + "1010111001000110101000100000001011001100", + "1010111001000110101000100000001011001101", + "1010111001000110101000100000001011001110", + "1010111001000110101000100000001011001111", + "1010111001000110101000100000001011010000", + "1010111001000110101000100000001011010001", + "1010111001000110101000100000001011010010", + "1010111001000110101000100000001011010011", + "1010111001000110101000100000001011010100", + "1010111001000110101000100000001011010101", + "1010111001000110101000100000001011010110", + "1010111001000110101000100000001011010111", + "1010111001000110101000100000001011011000", + "1010111001000110101000100000001011011001", + "1010111001000110101000100000001011011010", + "1010111001000110101000100000001011011011", + "1010111001000110101000100000001011011100", + "1010111001000110101000100000001011011101", + "1010111001000110101000100000001011011110", + "1010111001000110101000100000001011011111", + "1010111001000110101000100000001011100000", + "1010111001000110101000100000001011100001", + "1010111001000110101000100000001011100010", + "1010111001000110101000100000001011100011", + "1010111001000110101000100000001011100100", + "1010111001000110101000100000001011100101", + "1010111001000110101000100000001011100110", + "1010111001000110101000100000001011100111", + "1010111001000110101000100000001011101000", + "1010111001000110101000100000001011101001", + "1010111001000110101000100000001011101010", + "101011100100011010100010000000101110101100000000", + "101011100100011010100010000000101110101100000001", + "101011100100011010100010000000101110101100000010", + "101011100100011010100010000000101110101100000011", + "101011100100011010100010000000101110101100000100", + "101011100100011010100010000000101110101100000101", + "101011100100011010100010000000101110101100000110", + "101011100100011010100010000000101110101100000111", + "101011100100011010100010000000101110101100001000", + "101011100100011010100010000000101110101100001001", + "101011100100011010100010000000101110101100001010", + "101011100100011010100010000000101110101100001011", + "101011100100011010100010000000101110101100001100", + "101011100100011010100010000000101110101100001101", + "101011100100011010100010000000101110101100001110", + "101011100100011010100010000000101110101100001111", + "101011100100011010100010000000101110101100010000", + "101011100100011010100010000000101110101100010001", + "101011100100011010100010000000101110101100010010", + "101011100100011010100010000000101110101100010011", + "101011100100011010100010000000101110101100010100", + "101011100100011010100010000000101110101100010101", + "101011100100011010100010000000101110101100010110", + "101011100100011010100010000000101110101100010111", + "101011100100011010100010000000101110101100011000", + "101011100100011010100010000000101110101100011001", + "101011100100011010100010000000101110101100011010", + "101011100100011010100010000000101110101100011011", + "101011100100011010100010000000101110101100011100", + "101011100100011010100010000000101110101100011101", + "101011100100011010100010000000101110101100011110", + "101011100100011010100010000000101110101100011111", + "101011100100011010100010000000101110101100100000", + "101011100100011010100010000000101110101100100001", + "101011100100011010100010000000101110101100100010", + "101011100100011010100010000000101110101100100011", + "101011100100011010100010000000101110101100100100", + "101011100100011010100010000000101110101100100101", + "101011100100011010100010000000101110101100100110", + "101011100100011010100010000000101110101100100111", + "101011100100011010100010000000101110101100101000", + "101011100100011010100010000000101110101100101001", + "101011100100011010100010000000101110101100101010", + "101011100100011010100010000000101110101100101011", + "101011100100011010100010000000101110101100101100", + "101011100100011010100010000000101110101100101101", + "101011100100011010100010000000101110101100101110", + "101011100100011010100010000000101110101100101111", + "101011100100011010100010000000101110101100110000", + "101011100100011010100010000000101110101100110001", + "101011100100011010100010000000101110101100110010", + "101011100100011010100010000000101110101100110011", + "101011100100011010100010000000101110101100110100", + "101011100100011010100010000000101110101100110101", + "101011100100011010100010000000101110101100110110", + "101011100100011010100010000000101110101100110111", + "101011100100011010100010000000101110101100111000", + "101011100100011010100010000000101110101100111001", + "101011100100011010100010000000101110101100111010", + "101011100100011010100010000000101110101100111011", + "101011100100011010100010000000101110101100111100", + "101011100100011010100010000000101110101100111101", + "101011100100011010100010000000101110101100111110", + "101011100100011010100010000000101110101100111111", + "101011100100011010100010000000101110101101000000", + "101011100100011010100010000000101110101101000001", + "101011100100011010100010000000101110101101000010", + "101011100100011010100010000000101110101101000011", + "101011100100011010100010000000101110101101000100", + "101011100100011010100010000000101110101101000101", + "101011100100011010100010000000101110101101000110", + "101011100100011010100010000000101110101101000111", + "101011100100011010100010000000101110101101001000", + "101011100100011010100010000000101110101101001001", + "101011100100011010100010000000101110101101001010", + "101011100100011010100010000000101110101101001011", + "101011100100011010100010000000101110101101001100", + "101011100100011010100010000000101110101101001101", + "101011100100011010100010000000101110101101001110", + "101011100100011010100010000000101110101101001111", + "101011100100011010100010000000101110101101010000", + "101011100100011010100010000000101110101101010001", + "101011100100011010100010000000101110101101010010", + "101011100100011010100010000000101110101101010011", + "101011100100011010100010000000101110101101010100", + "101011100100011010100010000000101110101101010101", + "101011100100011010100010000000101110101101010110", + "101011100100011010100010000000101110101101010111", + "101011100100011010100010000000101110101101011000", + "101011100100011010100010000000101110101101011001", + "101011100100011010100010000000101110101101011010", + "101011100100011010100010000000101110101101011011", + "101011100100011010100010000000101110101101011100", + "101011100100011010100010000000101110101101011101", + "101011100100011010100010000000101110101101011110", + "101011100100011010100010000000101110101101011111", + "101011100100011010100010000000101110101101100000", + "101011100100011010100010000000101110101101100001", + "101011100100011010100010000000101110101101100010", + "101011100100011010100010000000101110101101100011", + "101011100100011010100010000000101110101101100100", + "101011100100011010100010000000101110101101100101", + "101011100100011010100010000000101110101101100110", + "101011100100011010100010000000101110101101100111", + "101011100100011010100010000000101110101101101000", + "101011100100011010100010000000101110101101101001", + "101011100100011010100010000000101110101101101010", + "101011100100011010100010000000101110101101101011", + "101011100100011010100010000000101110101101101100", + "101011100100011010100010000000101110101101101101", + "101011100100011010100010000000101110101101101110", + "101011100100011010100010000000101110101101101111", + "101011100100011010100010000000101110101101110000", + "101011100100011010100010000000101110101101110001", + "101011100100011010100010000000101110101101110010", + "101011100100011010100010000000101110101101110011", + "101011100100011010100010000000101110101101110100", + "101011100100011010100010000000101110101101110101", + "101011100100011010100010000000101110101101110110", + "101011100100011010100010000000101110101101110111", + "10101110010001101010001000000010111010110111100000000000", + "10101110010001101010001000000010111010110111100000000001", + "10101110010001101010001000000010111010110111100000000010", + "10101110010001101010001000000010111010110111100000000011", + "10101110010001101010001000000010111010110111100000000100", + "10101110010001101010001000000010111010110111100000000101", + "10101110010001101010001000000010111010110111100000000110", + "10101110010001101010001000000010111010110111100000000111", + "10101110010001101010001000000010111010110111100000001000", + "10101110010001101010001000000010111010110111100000001001", + "10101110010001101010001000000010111010110111100000001010", + "10101110010001101010001000000010111010110111100000001011", + "10101110010001101010001000000010111010110111100000001100", + "10101110010001101010001000000010111010110111100000001101", + "10101110010001101010001000000010111010110111100000001110", + "10101110010001101010001000000010111010110111100000001111", + "10101110010001101010001000000010111010110111100000010000", + "10101110010001101010001000000010111010110111100000010001", + "10101110010001101010001000000010111010110111100000010010", + "10101110010001101010001000000010111010110111100000010011", + "10101110010001101010001000000010111010110111100000010100", + "10101110010001101010001000000010111010110111100000010101", + "10101110010001101010001000000010111010110111100000010110", + "10101110010001101010001000000010111010110111100000010111", + "10101110010001101010001000000010111010110111100000011000", + "10101110010001101010001000000010111010110111100000011001", + "10101110010001101010001000000010111010110111100000011010", + "10101110010001101010001000000010111010110111100000011011", + "10101110010001101010001000000010111010110111100000011100", + "10101110010001101010001000000010111010110111100000011101", + "10101110010001101010001000000010111010110111100000011110", + "10101110010001101010001000000010111010110111100000011111", + "10101110010001101010001000000010111010110111100000100000", + "10101110010001101010001000000010111010110111100000100001", + "10101110010001101010001000000010111010110111100000100010", + "10101110010001101010001000000010111010110111100000100011", + "10101110010001101010001000000010111010110111100000100100", + "10101110010001101010001000000010111010110111100000100101", + "10101110010001101010001000000010111010110111100000100110", + "10101110010001101010001000000010111010110111100000100111", + "10101110010001101010001000000010111010110111100000101000", + "10101110010001101010001000000010111010110111100000101001", + "10101110010001101010001000000010111010110111100000101010", + "10101110010001101010001000000010111010110111100000101011", + "10101110010001101010001000000010111010110111100000101100", + "10101110010001101010001000000010111010110111100000101101", + "10101110010001101010001000000010111010110111100000101110", + "10101110010001101010001000000010111010110111100000101111", + "10101110010001101010001000000010111010110111100000110000", + "10101110010001101010001000000010111010110111100000110001", + "10101110010001101010001000000010111010110111100000110010", + "10101110010001101010001000000010111010110111100000110011", + "10101110010001101010001000000010111010110111100000110100", + "10101110010001101010001000000010111010110111100000110101", + "10101110010001101010001000000010111010110111100000110110", + "10101110010001101010001000000010111010110111100000110111", + "1010111001000110101000100000001011101011011110000011100000000000", + "1010111001000110101000100000001011101011011110000011100000000001", + "1010111001000110101000100000001011101011011110000011100000000010", + "1010111001000110101000100000001011101011011110000011100000000011", + "1010111001000110101000100000001011101011011110000011100000000100", + "1010111001000110101000100000001011101011011110000011100000000101", + "1010111001000110101000100000001011101011011110000011100000000110", + "1010111001000110101000100000001011101011011110000011100000000111", + "1010111001000110101000100000001011101011011110000011100000001000", + "1010111001000110101000100000001011101011011110000011100000001001", + "1010111001000110101000100000001011101011011110000011100000001010", + "1010111001000110101000100000001011101011011110000011100000001011", + "1010111001000110101000100000001011101011011110000011100000001100", + "1010111001000110101000100000001011101011011110000011100000001101", + "1010111001000110101000100000001011101011011110000011100000001110", + "1010111001000110101000100000001011101011011110000011100000001111", + "1010111001000110101000100000001011101011011110000011100000010000", + "1010111001000110101000100000001011101011011110000011100000010001", + "1010111001000110101000100000001011101011011110000011100000010010", + "1010111001000110101000100000001011101011011110000011100000010011", + "1010111001000110101000100000001011101011011110000011100000010100", + "1010111001000110101000100000001011101011011110000011100000010101", + "1010111001000110101000100000001011101011011110000011100000010110", + "1010111001000110101000100000001011101011011110000011100000010111", + "1010111001000110101000100000001011101011011110000011100000011000", + "1010111001000110101000100000001011101011011110000011100000011001", + "1010111001000110101000100000001011101011011110000011100000011010", + "1010111001000110101000100000001011101011011110000011100000011011", + "1010111001000110101000100000001011101011011110000011100000011100", + "1010111001000110101000100000001011101011011110000011100000011101", + "1010111001000110101000100000001011101011011110000011100000011110", + "1010111001000110101000100000001011101011011110000011100000011111", + "1010111001000110101000100000001011101011011110000011100000100000", + "1010111001000110101000100000001011101011011110000011100000100001", + "1010111001000110101000100000001011101011011110000011100000100010", + "1010111001000110101000100000001011101011011110000011100000100011", + "1010111001000110101000100000001011101011011110000011100000100100", + "1010111001000110101000100000001011101011011110000011100000100101", + "1010111001000110101000100000001011101011011110000011100000100110", + "1010111001000110101000100000001011101011011110000011100000100111", + "1010111001000110101000100000001011101011011110000011100000101000", + "1010111001000110101000100000001011101011011110000011100000101001", + "1010111001000110101000100000001011101011011110000011100000101010", + "1010111001000110101000100000001011101011011110000011100000101011", + "1010111001000110101000100000001011101011011110000011100000101100", + "1010111001000110101000100000001011101011011110000011100000101101", + "1010111001000110101000100000001011101011011110000011100000101110", + "1010111001000110101000100000001011101011011110000011100000101111", + "1010111001000110101000100000001011101011011110000011100000110000", + "1010111001000110101000100000001011101011011110000011100000110001", + "1010111001000110101000100000001011101011011110000011100000110010", + "1010111001000110101000100000001011101011011110000011100000110011", + "1010111001000110101000100000001011101011011110000011100000110100", + "1010111001000110101000100000001011101011011110000011100000110101", + "1010111001000110101000100000001011101011011110000011100000110110", + "1010111001000110101000100000001011101011011110000011100000110111", + "1010111001000110101000100000001011101011011110000011100000111000", + "1010111001000110101000100000001011101011011110000011100000111001", + "1010111001000110101000100000001011101011011110000011100000111010", + "1010111001000110101000100000001011101011011110000011100000111011", + "1010111001000110101000100000001011101011011110000011100000111100", + "1010111001000110101000100000001011101011011110000011100000111101", + "1010111001000110101000100000001011101011011110000011100000111110", + "1010111001000110101000100000001011101011011110000011100000111111", + "1010111001000110101000100000001011101011011110000011100001000000", + "1010111001000110101000100000001011101011011110000011100001000001", + "1010111001000110101000100000001011101011011110000011100001000010", + "1010111001000110101000100000001011101011011110000011100001000011", + "1010111001000110101000100000001011101011011110000011100001000100", + "1010111001000110101000100000001011101011011110000011100001000101", + "1010111001000110101000100000001011101011011110000011100001000110", + "1010111001000110101000100000001011101011011110000011100001000111", + "1010111001000110101000100000001011101011011110000011100001001000", + "1010111001000110101000100000001011101011011110000011100001001001", + "1010111001000110101000100000001011101011011110000011100001001010", + "1010111001000110101000100000001011101011011110000011100001001011", + "1010111001000110101000100000001011101011011110000011100001001100", + "1010111001000110101000100000001011101011011110000011100001001101", + "1010111001000110101000100000001011101011011110000011100001001110", + "1010111001000110101000100000001011101011011110000011100001001111", + "1010111001000110101000100000001011101011011110000011100001010000", + "1010111001000110101000100000001011101011011110000011100001010001", + "1010111001000110101000100000001011101011011110000011100001010010", + "1010111001000110101000100000001011101011011110000011100001010011", + "1010111001000110101000100000001011101011011110000011100001010100", + "1010111001000110101000100000001011101011011110000011100001010101", + "1010111001000110101000100000001011101011011110000011100001010110", + "1010111001000110101000100000001011101011011110000011100001010111", + "1010111001000110101000100000001011101011011110000011100001011000", + "1010111001000110101000100000001011101011011110000011100001011001", + "1010111001000110101000100000001011101011011110000011100001011010", + "1010111001000110101000100000001011101011011110000011100001011011", + "1010111001000110101000100000001011101011011110000011100001011100", + "1010111001000110101000100000001011101011011110000011100001011101", + "1010111001000110101000100000001011101011011110000011100001011110", + "1010111001000110101000100000001011101011011110000011100001011111", + "1010111001000110101000100000001011101011011110000011100001100000", + "1010111001000110101000100000001011101011011110000011100001100001", + "1010111001000110101000100000001011101011011110000011100001100010", + "1010111001000110101000100000001011101011011110000011100001100011", + "1010111001000110101000100000001011101011011110000011100001100100", + "1010111001000110101000100000001011101011011110000011100001100101", + "1010111001000110101000100000001011101011011110000011100001100110", + "1010111001000110101000100000001011101011011110000011100001100111", + "1010111001000110101000100000001011101011011110000011100001101000", + "1010111001000110101000100000001011101011011110000011100001101001", + "1010111001000110101000100000001011101011011110000011100001101010", + "1010111001000110101000100000001011101011011110000011100001101011", + "1010111001000110101000100000001011101011011110000011100001101100", + "1010111001000110101000100000001011101011011110000011100001101101", + "1010111001000110101000100000001011101011011110000011100001101110", + "1010111001000110101000100000001011101011011110000011100001101111", + "1010111001000110101000100000001011101011011110000011100001110000", + "1010111001000110101000100000001011101011011110000011100001110001", + "1010111001000110101000100000001011101011011110000011100001110010", + "1010111001000110101000100000001011101011011110000011100001110011", + "1010111001000110101000100000001011101011011110000011100001110100", + "1010111001000110101000100000001011101011011110000011100001110101", + "1010111001000110101000100000001011101011011110000011100001110110", + "1010111001000110101000100000001011101011011110000011100001110111", + "1010111001000110101000100000001011101011011110000011100001111000", + "1010111001000110101000100000001011101011011110000011100001111001", + "1010111001000110101000100000001011101011011110000011100001111010", + "1010111001000110101000100000001011101011011110000011100001111011", + "1010111001000110101000100000001011101011011110000011100001111100", + "1010111001000110101000100000001011101011011110000011100001111101", + "1010111001000110101000100000001011101011011110000011100001111110", + "1010111001000110101000100000001011101011011110000011100001111111", + "1010111001000110101000100000001011101011011110000011100010000000", + "1010111001000110101000100000001011101011011110000011100010000001", + "1010111001000110101000100000001011101011011110000011100010000010", + "1010111001000110101000100000001011101011011110000011100010000011", + "1010111001000110101000100000001011101011011110000011100010000100", + "101011100100011010100010000000101110101101111000001110001000010100000000", + "101011100100011010100010000000101110101101111000001110001000010100000001", + "101011100100011010100010000000101110101101111000001110001000010100000010", + "101011100100011010100010000000101110101101111000001110001000010100000011", + "101011100100011010100010000000101110101101111000001110001000010100000100", + "101011100100011010100010000000101110101101111000001110001000010100000101", + "101011100100011010100010000000101110101101111000001110001000010100000110", + "101011100100011010100010000000101110101101111000001110001000010100000111", + "101011100100011010100010000000101110101101111000001110001000010100001000", + "101011100100011010100010000000101110101101111000001110001000010100001001", + "101011100100011010100010000000101110101101111000001110001000010100001010", + "101011100100011010100010000000101110101101111000001110001000010100001011", + "101011100100011010100010000000101110101101111000001110001000010100001100", + "10101110010001101010001000000010111010110111100000111000100001010000110100000000", + "10101110010001101010001000000010111010110111100000111000100001010000110100000001", + "10101110010001101010001000000010111010110111100000111000100001010000110100000010", + "10101110010001101010001000000010111010110111100000111000100001010000110100000011", + "10101110010001101010001000000010111010110111100000111000100001010000110100000100", + "10101110010001101010001000000010111010110111100000111000100001010000110100000101", + "10101110010001101010001000000010111010110111100000111000100001010000110100000110", + "10101110010001101010001000000010111010110111100000111000100001010000110100000111", + "10101110010001101010001000000010111010110111100000111000100001010000110100001000", + "10101110010001101010001000000010111010110111100000111000100001010000110100001001", + "10101110010001101010001000000010111010110111100000111000100001010000110100001010", + "10101110010001101010001000000010111010110111100000111000100001010000110100001011", + "10101110010001101010001000000010111010110111100000111000100001010000110100001100", + "10101110010001101010001000000010111010110111100000111000100001010000110100001101", + "10101110010001101010001000000010111010110111100000111000100001010000110100001110", + "10101110010001101010001000000010111010110111100000111000100001010000110100001111", + "10101110010001101010001000000010111010110111100000111000100001010000110100010000", + "10101110010001101010001000000010111010110111100000111000100001010000110100010001", + "10101110010001101010001000000010111010110111100000111000100001010000110100010010", + "10101110010001101010001000000010111010110111100000111000100001010000110100010011", + "10101110010001101010001000000010111010110111100000111000100001010000110100010100", + "10101110010001101010001000000010111010110111100000111000100001010000110100010101", + "10101110010001101010001000000010111010110111100000111000100001010000110100010110", + "10101110010001101010001000000010111010110111100000111000100001010000110100010111", + "10101110010001101010001000000010111010110111100000111000100001010000110100011000", + "10101110010001101010001000000010111010110111100000111000100001010000110100011001", + "10101110010001101010001000000010111010110111100000111000100001010000110100011010", + "10101110010001101010001000000010111010110111100000111000100001010000110100011011", + "10101110010001101010001000000010111010110111100000111000100001010000110100011100", + "10101110010001101010001000000010111010110111100000111000100001010000110100011101", + "10101110010001101010001000000010111010110111100000111000100001010000110100011110", + "10101110010001101010001000000010111010110111100000111000100001010000110100011111", + "10101110010001101010001000000010111010110111100000111000100001010000110100100000", + "10101110010001101010001000000010111010110111100000111000100001010000110100100001", + "10101110010001101010001000000010111010110111100000111000100001010000110100100010", + "10101110010001101010001000000010111010110111100000111000100001010000110100100011", + "10101110010001101010001000000010111010110111100000111000100001010000110100100100", + "10101110010001101010001000000010111010110111100000111000100001010000110100100101", + "10101110010001101010001000000010111010110111100000111000100001010000110100100110", + "10101110010001101010001000000010111010110111100000111000100001010000110100100111", + "10101110010001101010001000000010111010110111100000111000100001010000110100101000", + "10101110010001101010001000000010111010110111100000111000100001010000110100101001", + "10101110010001101010001000000010111010110111100000111000100001010000110100101010", + "10101110010001101010001000000010111010110111100000111000100001010000110100101011", + "10101110010001101010001000000010111010110111100000111000100001010000110100101100", + "10101110010001101010001000000010111010110111100000111000100001010000110100101101", + "10101110010001101010001000000010111010110111100000111000100001010000110100101110", + "10101110010001101010001000000010111010110111100000111000100001010000110100101111", + "10101110010001101010001000000010111010110111100000111000100001010000110100110000", + "10101110010001101010001000000010111010110111100000111000100001010000110100110001", + "10101110010001101010001000000010111010110111100000111000100001010000110100110010", + "10101110010001101010001000000010111010110111100000111000100001010000110100110011", + "10101110010001101010001000000010111010110111100000111000100001010000110100110100", + "10101110010001101010001000000010111010110111100000111000100001010000110100110101", + "10101110010001101010001000000010111010110111100000111000100001010000110100110110", + "10101110010001101010001000000010111010110111100000111000100001010000110100110111", + "10101110010001101010001000000010111010110111100000111000100001010000110100111000", + "10101110010001101010001000000010111010110111100000111000100001010000110100111001", + "10101110010001101010001000000010111010110111100000111000100001010000110100111010", + "10101110010001101010001000000010111010110111100000111000100001010000110100111011", + "10101110010001101010001000000010111010110111100000111000100001010000110100111100", + "10101110010001101010001000000010111010110111100000111000100001010000110100111101", + "10101110010001101010001000000010111010110111100000111000100001010000110100111110", + "10101110010001101010001000000010111010110111100000111000100001010000110100111111", + "10101110010001101010001000000010111010110111100000111000100001010000110101000000", + "10101110010001101010001000000010111010110111100000111000100001010000110101000001", + "10101110010001101010001000000010111010110111100000111000100001010000110101000010", + "10101110010001101010001000000010111010110111100000111000100001010000110101000011", + "10101110010001101010001000000010111010110111100000111000100001010000110101000100", + "10101110010001101010001000000010111010110111100000111000100001010000110101000101", + "10101110010001101010001000000010111010110111100000111000100001010000110101000110", + "10101110010001101010001000000010111010110111100000111000100001010000110101000111", + "10101110010001101010001000000010111010110111100000111000100001010000110101001000", + "10101110010001101010001000000010111010110111100000111000100001010000110101001001", + "10101110010001101010001000000010111010110111100000111000100001010000110101001010", + "10101110010001101010001000000010111010110111100000111000100001010000110101001011", + "10101110010001101010001000000010111010110111100000111000100001010000110101001100", + "10101110010001101010001000000010111010110111100000111000100001010000110101001101", + "10101110010001101010001000000010111010110111100000111000100001010000110101001110", + "10101110010001101010001000000010111010110111100000111000100001010000110101001111", + "10101110010001101010001000000010111010110111100000111000100001010000110101010000", + "10101110010001101010001000000010111010110111100000111000100001010000110101010001", + "10101110010001101010001000000010111010110111100000111000100001010000110101010010", + "10101110010001101010001000000010111010110111100000111000100001010000110101010011", + "10101110010001101010001000000010111010110111100000111000100001010000110101010100", + "10101110010001101010001000000010111010110111100000111000100001010000110101010101", + "10101110010001101010001000000010111010110111100000111000100001010000110101010110", + "10101110010001101010001000000010111010110111100000111000100001010000110101010111", + "10101110010001101010001000000010111010110111100000111000100001010000110101011000", + "10101110010001101010001000000010111010110111100000111000100001010000110101011001", + "10101110010001101010001000000010111010110111100000111000100001010000110101011010", + "10101110010001101010001000000010111010110111100000111000100001010000110101011011", + "10101110010001101010001000000010111010110111100000111000100001010000110101011100", + "10101110010001101010001000000010111010110111100000111000100001010000110101011101", + "10101110010001101010001000000010111010110111100000111000100001010000110101011110", + "10101110010001101010001000000010111010110111100000111000100001010000110101011111", + "10101110010001101010001000000010111010110111100000111000100001010000110101100000", + "10101110010001101010001000000010111010110111100000111000100001010000110101100001", + "10101110010001101010001000000010111010110111100000111000100001010000110101100010", + "10101110010001101010001000000010111010110111100000111000100001010000110101100011", + "10101110010001101010001000000010111010110111100000111000100001010000110101100100", + "10101110010001101010001000000010111010110111100000111000100001010000110101100101", + "10101110010001101010001000000010111010110111100000111000100001010000110101100110", + "10101110010001101010001000000010111010110111100000111000100001010000110101100111", + "10101110010001101010001000000010111010110111100000111000100001010000110101101000", + "10101110010001101010001000000010111010110111100000111000100001010000110101101001", + "10101110010001101010001000000010111010110111100000111000100001010000110101101010", + "10101110010001101010001000000010111010110111100000111000100001010000110101101011", + "10101110010001101010001000000010111010110111100000111000100001010000110101101100", + "10101110010001101010001000000010111010110111100000111000100001010000110101101101", + "10101110010001101010001000000010111010110111100000111000100001010000110101101110", + "10101110010001101010001000000010111010110111100000111000100001010000110101101111", + "10101110010001101010001000000010111010110111100000111000100001010000110101110000", + "10101110010001101010001000000010111010110111100000111000100001010000110101110001", + "10101110010001101010001000000010111010110111100000111000100001010000110101110010", + "10101110010001101010001000000010111010110111100000111000100001010000110101110011", + "10101110010001101010001000000010111010110111100000111000100001010000110101110100", + "10101110010001101010001000000010111010110111100000111000100001010000110101110101", + "10101110010001101010001000000010111010110111100000111000100001010000110101110110", + "10101110010001101010001000000010111010110111100000111000100001010000110101110111", + "10101110010001101010001000000010111010110111100000111000100001010000110101111000", + "10101110010001101010001000000010111010110111100000111000100001010000110101111001", + "10101110010001101010001000000010111010110111100000111000100001010000110101111010", + "10101110010001101010001000000010111010110111100000111000100001010000110101111011", + "10101110010001101010001000000010111010110111100000111000100001010000110101111100", + "10101110010001101010001000000010111010110111100000111000100001010000110101111101", + "10101110010001101010001000000010111010110111100000111000100001010000110101111110", + "10101110010001101010001000000010111010110111100000111000100001010000110101111111", + "10101110010001101010001000000010111010110111100000111000100001010000110110000000", + "10101110010001101010001000000010111010110111100000111000100001010000110110000001", + "10101110010001101010001000000010111010110111100000111000100001010000110110000010", + "10101110010001101010001000000010111010110111100000111000100001010000110110000011", + "10101110010001101010001000000010111010110111100000111000100001010000110110000100", + "10101110010001101010001000000010111010110111100000111000100001010000110110000101", + "10101110010001101010001000000010111010110111100000111000100001010000110110000110", + "10101110010001101010001000000010111010110111100000111000100001010000110110000111", + "10101110010001101010001000000010111010110111100000111000100001010000110110001000", + "10101110010001101010001000000010111010110111100000111000100001010000110110001001", + "10101110010001101010001000000010111010110111100000111000100001010000110110001010", + "10101110010001101010001000000010111010110111100000111000100001010000110110001011", + "10101110010001101010001000000010111010110111100000111000100001010000110110001100", + "10101110010001101010001000000010111010110111100000111000100001010000110110001101", + "10101110010001101010001000000010111010110111100000111000100001010000110110001110", + "10101110010001101010001000000010111010110111100000111000100001010000110110001111", + "10101110010001101010001000000010111010110111100000111000100001010000110110010000", + "10101110010001101010001000000010111010110111100000111000100001010000110110010001", + "10101110010001101010001000000010111010110111100000111000100001010000110110010010", + "10101110010001101010001000000010111010110111100000111000100001010000110110010011", + "10101110010001101010001000000010111010110111100000111000100001010000110110010100", + "10101110010001101010001000000010111010110111100000111000100001010000110110010101", + "10101110010001101010001000000010111010110111100000111000100001010000110110010110", + "10101110010001101010001000000010111010110111100000111000100001010000110110010111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100000000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100000001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100000010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100000011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100000100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100000101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100000110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100000111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100001000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100001001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100001010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100001011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100001100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100001101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100001110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100001111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100010000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100010001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100010010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100010011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100010100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100010101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100010110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100010111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100011000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100011001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100011010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100011011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100011100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100011101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100011110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100011111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100100000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100100001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100100010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100100011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100100100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100100101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100100110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100100111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100101000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100101001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100101010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100101011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100101100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100101101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100101110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100101111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100110000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100110001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100110010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100110011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100110100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100110101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100110110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100110111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100111000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100111001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100111010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100111011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100111100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100111101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100111110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101100111111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101000000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101000001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101000010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101000011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101000100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101000101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101000110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101000111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101001000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101001001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101001010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101001011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101001100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101001101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101001110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101001111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101010000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101010001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101010010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101010011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101010100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101010101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101010110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101010111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101011000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101011001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101011010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101011011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101011100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101011101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101011110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101011111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101100000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101100001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101100010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101100011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101100100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101100101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101100110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101100111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101101000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101101001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101101010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101101011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101101100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101101101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101101110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101101111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101110000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101110001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101110010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101110011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101110100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101110101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101110110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101110111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101111000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101111001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101111010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101111011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101111100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101111101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101111110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101101111111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110000000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110000001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110000010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110000011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110000100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110000101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110000110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110000111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110001000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110001001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110001010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110001011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110001100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110001101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110001110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110001111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000000000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000000001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000000010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000000011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000000100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000000101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000000110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000000111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000001000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000001001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000001010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000001011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000001100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000001101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000001110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000001111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000010000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000010001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000010010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000010011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000010100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000010101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000010110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000010111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000011000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000011001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000011010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000011011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000011100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000011101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000011110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000011111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000100000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000100001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000100010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000100011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000100100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000100101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000100110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000100111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000101000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000101001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000101010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000101011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000101100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000101101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000101110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000101111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000110000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000110001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000110010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000110011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000110100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000110101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000110110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000110111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000111000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000111001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000111010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000111011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000111100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000111101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000111110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000000111111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001000000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001000001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001000010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001000011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001000100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001000101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001000110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001000111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001001000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001001001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001001010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001001011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001001100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001001101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001001110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001001111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001010000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001010001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001010010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001010011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001010100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001010101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001010110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001010111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001011000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001011001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001011010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001011011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001011100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001011101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001011110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001011111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001100000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001100001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001100010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001100011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001100100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001100101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001100110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001100111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001101000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001101001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001101010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001101011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001101100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001101101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001101110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001101111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001110000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001110001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001110010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001110011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001110100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001110101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001110110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001110111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001111000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001111001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001111010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001111011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001111100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001111101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001111110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000001111111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010000000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010000001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010000010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010000011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010000100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010000101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010000110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010000111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010001000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010001001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010001010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010001011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010001100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010001101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010001110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010001111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010010000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010010001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010010010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010010011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010010100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010010101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010010110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010010111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010011000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010011001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010011010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010011011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010011100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010011101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010011110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010011111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010100000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010100001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010100010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010100011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010100100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010100101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010100110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010100111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010101000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010101001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010101010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010101011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010101100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010101101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010101110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010101111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010110000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010110001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010110010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010110011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010110100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010110101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010110110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010110111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010111000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010111001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010111010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010111011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010111100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010111101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010111110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000010111111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011000000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011000001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011000010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011000011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011000100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011000101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011000110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011000111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011001000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011001001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011001010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011001011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011001100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011001101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011001110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011001111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011010000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011010001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011010010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011010011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011010100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011010101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011010110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011010111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011011000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011011001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011011010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011011011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011011100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011011101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011011110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011011111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011100000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011100001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011100010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011100011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011100100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011100101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011100110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011100111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000000000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000000001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000000010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000000011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000000100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000000101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000000110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000000111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000001000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000001001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000001010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000001011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000001100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000001101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000001110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000001111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100000000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100000001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100000010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100000011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100000100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100000101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100000110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100000111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100001000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100001001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100001010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100001011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100001100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100001101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100001110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100001111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100010000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100010001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100010010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100010011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100010100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100010101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100010110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100010111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100011000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100011001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100011010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100011011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100011100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100011101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100011110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100011111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100100000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100100001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100100010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100100011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100100100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100100101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100100110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100100111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100101000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100101001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100101010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100101011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100101100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100101101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100101110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100101111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100110000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100110001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100110010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100110011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100110100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100110101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100110110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100110111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100111000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100111001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100111010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100111011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100111100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100111101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100111110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000100111111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101000000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101000001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101000010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101000011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101000100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101000101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101000110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101000111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101001000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101001001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101001010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101001011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101001100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101001101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101001110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101001111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101010000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101010001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101010010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101010011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101010100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101010101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101010110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101010111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101011000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101011001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101011010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101011011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101011100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101011101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101011110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101011111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101100000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101100001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101100010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101100011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101100100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101100101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101100110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101100111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101101000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101101001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101101010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101101011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101101100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101101101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101101110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101101111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101110000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101110001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101110010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101110011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101110100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101110101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101110110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101110111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101111000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101111001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101111010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101111011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101111100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101111101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101111110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000101111111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110000000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110000001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110000010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110000011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110000100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110000101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110000110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110000111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110001000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110001001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110001010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110001011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110001100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110001101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110001110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110001111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110010000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110010001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110010010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110010011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110010100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110010101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110010110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110010111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110011000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110011001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110011010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110011011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110011100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110011101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110011110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110011111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110100000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110100001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110100010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110100011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110100100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110100101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110100110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110100111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110101000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110101001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110101010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110101011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110101100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110101101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110101110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110101111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110110000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110110001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110110010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110110011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110110100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110110101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110110110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110110111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110111000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110111001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110111010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110111011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110111100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110111101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110111110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000110111111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111000000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111000001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111000010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111000011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111000100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111000101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111000110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111000111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111001000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111001001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111001010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111001011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111001100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111001101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111001110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111001111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111010000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111010001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111010010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111010011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111010100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111010101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111010110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111010111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111011000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111011001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111011010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111011011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111011100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111011101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111011110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111011111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111100000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111100001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111100010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111100011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111100100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111100101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111100110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111100111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111101000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111101001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111101010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111101011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111101100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111101101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111101110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111101111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111110000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111110001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111110010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111110011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111110100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111110101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111110110", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111110111", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111111000", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111111001", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111111010", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111111011", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111111100", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111111101", + "1010111001000110101000100000001011101011011110000011100010000101000011011001101110010000111011000001000111111110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100000000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100000001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100000010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100000011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100000100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100000101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100000110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100000111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100001000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100001001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100001010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100001011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100001100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100001101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100001110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100001111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100010000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100010001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100010010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100010011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100010100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100010101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100010110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100010111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100011000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100011001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100011010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100011011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100011100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100011101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100011110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100011111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100100000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100100001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100100010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100100011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100100100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100100101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100100110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100100111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100101000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100101001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100101010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100101011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100101100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100101101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100101110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100101111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100110000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100110001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100110010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100110011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100110100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100110101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100110110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100110111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100111000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100111001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100111010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100111011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100111100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100111101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100111110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111100111111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101000000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101000001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101000010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101000011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101000100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101000101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101000110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101000111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101001000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101001001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101001010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101001011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101001100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101001101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101001110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101001111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101010000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101010001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101010010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101010011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101010100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101010101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101010110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101010111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101011000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101011001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101011010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101011011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101011100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101011101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101011110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101011111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101100000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101100001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101100010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101100011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101100100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101100101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101100110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101100111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101101000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101101001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101101010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101101011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101101100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101101101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101101110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101101111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101110000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101110001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101110010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101110011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101110100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101110101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101110110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101110111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101111000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101111001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101111010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101111011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101111100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101111101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101111110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111101111111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110000000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110000001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110000010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110000011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110000100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110000101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110000110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110000111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110001000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110001001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110001010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110001011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110001100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110001101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110001110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110001111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110010000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110010001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110010010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110010011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110010100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110010101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110010110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110010111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110011000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110011001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110011010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110011011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110011100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110011101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110011110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110011111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110100000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110100001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110100010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110100011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110100100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110100101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110100110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110100111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110101000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110101001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110101010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110101011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110101100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110101101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110101110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110101111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110110000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110110001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110110010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110110011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110110100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110110101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110110110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110110111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110111000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110111001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110111010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110111011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110111100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110111101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110111110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111110111111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111000000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111000001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111000010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111000011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111000100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111000101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111000110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111000111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111001000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111001001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111001010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111001011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111001100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111001101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111001110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111001111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111010000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111010001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111010010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111010011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111010100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111010101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111010110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111010111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111011000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111011001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111011010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111011011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111011100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111011101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111011110", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111011111", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111100000", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111100001", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111100010", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111100011", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111100100", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111100101", + "101011100100011010100010000000101110101101111000001110001000010100001101100110111001000011101100000100011111111111100110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100000000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100000001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100000010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100000011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100000100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100000101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100000110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100000111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100001000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100001001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100001010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100001011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100001100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100001101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100001110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100001111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100010000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100010001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100010010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100010011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100010100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100010101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100010110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100010111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100011000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100011001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100011010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100011011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100011100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100011101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100011110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100011111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100100000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100100001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100100010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100100011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100100100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100100101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100100110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100100111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100101000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100101001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100101010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100101011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100101100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100101101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100101110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100101111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100110000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100110001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100110010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100110011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100110100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100110101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100110110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100110111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100111000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100111001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100111010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100111011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100111100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100111101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100111110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011100111111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101000000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101000001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101000010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101000011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101000100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101000101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101000110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101000111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101001000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101001001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101001010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101001011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101001100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101001101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101001110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101001111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101010000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101010001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101010010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101010011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101010100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101010101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101010110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101010111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101011000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101011001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101011010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101011011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101011100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101011101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101011110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101011111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101100000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101100001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101100010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101100011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101100100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101100101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101100110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101100111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101101000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101101001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101101010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101101011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101101100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101101101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101101110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101101111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101110000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101110001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101110010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101110011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101110100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101110101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101110110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101110111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101111000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101111001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101111010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101111011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101111100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101111101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101111110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011101111111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110000000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110000001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110000010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110000011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110000100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110000101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110000110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110000111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110001000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110001001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110001010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110001011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110001100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110001101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110001110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110001111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110010000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110010001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110010010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110010011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110010100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110010101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110010110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110010111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110011000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110011001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110011010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110011011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110011100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110011101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110011110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110011111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110100000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110100001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110100010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110100011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110100100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110100101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110100110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110100111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110101000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110101001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110101010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110101011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110101100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110101101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110101110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110101111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110110000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110110001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110110010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110110011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110110100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110110101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110110110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110110111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110111000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110111001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110111010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110111011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110111100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110111101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110111110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011110111111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111000000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111000001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111000010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111000011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111000100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111000101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111000110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111000111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111001000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111001001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111001010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111001011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111001100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111001101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111001110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111001111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111010000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111010001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111010010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111010011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111010100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111010101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111010110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111010111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111011000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111011001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111011010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111011011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111011100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111011101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111011110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111011111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111100000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111100001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111100010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111100011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111100100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111100101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111100110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111100111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111101000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111101001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111101010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111101011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111101100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111101101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111101110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111101111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111110000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111110001", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111110010", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111110011", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111110100", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111110101", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111110110", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111110111", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111111000", + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111111001", + }, +}, +{ + .lowerBound = mc_dec128_from_string("123456789.000000"), + .includeLowerBound = true, + .upperBound = mc_dec128_from_string("123456789.000000"), + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = mc_dec128_from_string("-1000000000000000L") }, + .max = { .set = true, .value = MC_DEC128(0x7000000000000000L) }, + .expectMincoverStrings = { + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111111001", + }, +}, +{ + .lowerBound = mc_dec128_from_string("123456789.000000"), + .includeLowerBound = true, + .upperBound = mc_dec128_from_string("123456789.000000"), + .includeUpperBound = true, + .sparsity = 8, + .min = { .set = true, .value = mc_dec128_from_string("-1000000000000000L") }, + .max = { .set = true, .value = MC_DEC128(0x7000000000000000L) }, + .expectMincoverStrings = { + "10101110010001101010001000000010111010110111100000111000100001010000110110011011100100001110110000010001111111111110011111111001", + }, +}, diff --git a/test/data/range-min-cover/mincover_decimal128_precision.cstruct b/test/data/range-min-cover/mincover_decimal128_precision.cstruct new file mode 100644 index 000000000..3d11b4cbf --- /dev/null +++ b/test/data/range-min-cover/mincover_decimal128_precision.cstruct @@ -0,0 +1,312 @@ +// This code is GENERATED! Do not edit! +// clang-format off +{ + .lowerBound = mc_dec128_from_string("0.000000"), + .includeLowerBound = true, + .upperBound = mc_dec128_from_string("1.638400"), + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = mc_dec128_from_string("0.000000") }, + .max = { .set = true, .value = mc_dec128_from_string("6.500000") }, + .precision = { .set = true, .value = 1 }, + .expectMincoverStrings = { + "000", + "0010000", + }, +}, +{ + .lowerBound = mc_dec128_from_string("0.000000"), + .includeLowerBound = true, + .upperBound = mc_dec128_from_string("1.638400"), + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = mc_dec128_from_string("0.000000") }, + .max = { .set = true, .value = mc_dec128_from_string("6.550000") }, + .precision = { .set = true, .value = 2 }, + .expectMincoverStrings = { + "000", + "00100", + "00101000", + }, +}, +{ + .lowerBound = mc_dec128_from_string("0.000000"), + .includeLowerBound = true, + .upperBound = mc_dec128_from_string("1.638400"), + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = mc_dec128_from_string("0.000000") }, + .max = { .set = true, .value = mc_dec128_from_string("6.553000") }, + .precision = { .set = true, .value = 3 }, + .expectMincoverStrings = { + "000", + "0010", + "0011000", + "00110010", + "00110011000", + "001100110010", + "0011001100110", + }, +}, +{ + .lowerBound = mc_dec128_from_string("0.000000"), + .includeLowerBound = true, + .upperBound = mc_dec128_from_string("1.638400"), + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = mc_dec128_from_string("0.000000") }, + .max = { .set = true, .value = mc_dec128_from_string("6.553600") }, + .precision = { .set = true, .value = 4 }, + .expectMincoverStrings = { + "000", + "00100000000000000", + }, +}, +{ + .lowerBound = mc_dec128_from_string("1000000.000000"), + .includeLowerBound = true, + .upperBound = mc_dec128_from_string("20000000.000000"), + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = mc_dec128_from_string("788545.000000") }, + .max = { .set = true, .value = mc_dec128_from_string("340282366920938463463374607431769000000.000000") }, + .precision = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111110111111111111111111110011111111011", + "101011100100001010111100010111101100010001100010001110011000100110010011110111101000001011111101111111111111111111100111111111", + "101011100100001010111100010111101100010001100010001110011000100110010011110111101000001011111101111111111111111111101", + "10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111110111111111111111111111", + "10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111111", + "1010111001000010101111000101111011000100011000100011100110001001100100111101111010000011", + "10101110010000101011110001011110110001000110001000111001100010011001001111011110100001", + "1010111001000010101111000101111011000100011000100011100110001001100100111101111010001", + "101011100100001010111100010111101100010001100010001110011000100110010011110111101001", + "10101110010000101011110001011110110001000110001000111001100010011001001111011110101", + "1010111001000010101111000101111011000100011000100011100110001001100100111101111011", + "10101110010000101011110001011110110001000110001000111001100010011001001111011111", + "101011100100001010111100010111101100010001100010001110011000100110010011111", + "1010111001000010101111000101111011000100011000100011100110001001100101", + "101011100100001010111100010111101100010001100010001110011000100110011", + "1010111001000010101111000101111011000100011000100011100110001001101", + "101011100100001010111100010111101100010001100010001110011000100111", + "101011100100001010111100010111101100010001100010001110011000101", + "10101110010000101011110001011110110001000110001000111001100011", + "101011100100001010111100010111101100010001100010001110011001", + "10101110010000101011110001011110110001000110001000111001101", + "1010111001000010101111000101111011000100011000100011100111", + "1010111001000010101111000101111011000100011000100011101", + "101011100100001010111100010111101100010001100010001111", + "10101110010000101011110001011110110001000110001001", + "1010111001000010101111000101111011000100011000101", + "101011100100001010111100010111101100010001100011", + "1010111001000010101111000101111011000100011001", + "101011100100001010111100010111101100010001101", + "10101110010000101011110001011110110001000111", + "10101110010000101011110001011110110001001", + "1010111001000010101111000101111011000101", + "101011100100001010111100010111101100011", + "1010111001000010101111000101111011001", + "101011100100001010111100010111101101", + "10101110010000101011110001011110111", + "10101110010000101011110001011111", + "101011100100001010111100011", + "1010111001000010101111001", + "101011100100001010111101", + "10101110010000101011111", + "101011100100001011", + "1010111001000011", + "10101110010001000", + "101011100100010010", + "10101110010001001100", + "101011100100010011010", + "10101110010001001101100", + "1010111001000100110110100", + "101011100100010011011010100", + "1010111001000100110110101010", + "101011100100010011011010101100", + "1010111001000100110110101011010", + "1010111001000100110110101011011000", + "1010111001000100110110101011011001000", + "1010111001000100110110101011011001001000", + "101011100100010011011010101101100100100100", + "10101110010001001101101010110110010010010100", + "1010111001000100110110101011011001001001010100", + "10101110010001001101101010110110010010010101010000", + "10101110010001001101101010110110010010010101010001000", + "101011100100010011011010101101100100100101010100010010", + "1010111001000100110110101011011001001001010101000100110", + "101011100100010011011010101101100100100101010100010011100", + "1010111001000100110110101011011001001001010101000100111010", + "101011100100010011011010101101100100100101010100010011101100", + "1010111001000100110110101011011001001001010101000100111011010", + "10101110010001001101101010110110010010010101010001001110110110", + "1010111001000100110110101011011001001001010101000100111011011100", + "1010111001000100110110101011011001001001010101000100111011011101000000", + "101011100100010011011010101101100100100101010100010011101101110100000100000", + "10101110010001001101101010110110010010010101010001001110110111010000010000100", + "101011100100010011011010101101100100100101010100010011101101110100000100001010", + "10101110010001001101101010110110010010010101010001001110110111010000010000101100", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110100", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101010", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101100", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011010", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110000", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100010", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001100", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110100", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101010", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101110", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111110", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111110", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111110", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111110", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111110", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111000", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110010", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111111100110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011110", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111111100111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001111110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001111111100", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011111111010", + }, +}, +{ + .lowerBound = mc_dec128_from_string("1000000.000000"), + .includeLowerBound = true, + .upperBound = mc_dec128_from_string("20000000.000000"), + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = mc_dec128_from_string("788544.000000") }, + .max = { .set = true, .value = mc_dec128_from_string("340282366920938463463374607431769000000.000000") }, + .precision = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111110111111111111111111110011111111011", + "101011100100001010111100010111101100010001100010001110011000100110010011110111101000001011111101111111111111111111100111111111", + "101011100100001010111100010111101100010001100010001110011000100110010011110111101000001011111101111111111111111111101", + "10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111110111111111111111111111", + "10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111111", + "1010111001000010101111000101111011000100011000100011100110001001100100111101111010000011", + "10101110010000101011110001011110110001000110001000111001100010011001001111011110100001", + "1010111001000010101111000101111011000100011000100011100110001001100100111101111010001", + "101011100100001010111100010111101100010001100010001110011000100110010011110111101001", + "10101110010000101011110001011110110001000110001000111001100010011001001111011110101", + "1010111001000010101111000101111011000100011000100011100110001001100100111101111011", + "10101110010000101011110001011110110001000110001000111001100010011001001111011111", + "101011100100001010111100010111101100010001100010001110011000100110010011111", + "1010111001000010101111000101111011000100011000100011100110001001100101", + "101011100100001010111100010111101100010001100010001110011000100110011", + "1010111001000010101111000101111011000100011000100011100110001001101", + "101011100100001010111100010111101100010001100010001110011000100111", + "101011100100001010111100010111101100010001100010001110011000101", + "10101110010000101011110001011110110001000110001000111001100011", + "101011100100001010111100010111101100010001100010001110011001", + "10101110010000101011110001011110110001000110001000111001101", + "1010111001000010101111000101111011000100011000100011100111", + "1010111001000010101111000101111011000100011000100011101", + "101011100100001010111100010111101100010001100010001111", + "10101110010000101011110001011110110001000110001001", + "1010111001000010101111000101111011000100011000101", + "101011100100001010111100010111101100010001100011", + "1010111001000010101111000101111011000100011001", + "101011100100001010111100010111101100010001101", + "10101110010000101011110001011110110001000111", + "10101110010000101011110001011110110001001", + "1010111001000010101111000101111011000101", + "101011100100001010111100010111101100011", + "1010111001000010101111000101111011001", + "101011100100001010111100010111101101", + "10101110010000101011110001011110111", + "10101110010000101011110001011111", + "101011100100001010111100011", + "1010111001000010101111001", + "101011100100001010111101", + "10101110010000101011111", + "101011100100001011", + "1010111001000011", + "10101110010001000", + "101011100100010010", + "10101110010001001100", + "101011100100010011010", + "10101110010001001101100", + "1010111001000100110110100", + "101011100100010011011010100", + "1010111001000100110110101010", + "101011100100010011011010101100", + "1010111001000100110110101011010", + "1010111001000100110110101011011000", + "1010111001000100110110101011011001000", + "1010111001000100110110101011011001001000", + "101011100100010011011010101101100100100100", + "10101110010001001101101010110110010010010100", + "1010111001000100110110101011011001001001010100", + "10101110010001001101101010110110010010010101010000", + "10101110010001001101101010110110010010010101010001000", + "101011100100010011011010101101100100100101010100010010", + "1010111001000100110110101011011001001001010101000100110", + "101011100100010011011010101101100100100101010100010011100", + "1010111001000100110110101011011001001001010101000100111010", + "101011100100010011011010101101100100100101010100010011101100", + "1010111001000100110110101011011001001001010101000100111011010", + "10101110010001001101101010110110010010010101010001001110110110", + "1010111001000100110110101011011001001001010101000100111011011100", + "1010111001000100110110101011011001001001010101000100111011011101000000", + "101011100100010011011010101101100100100101010100010011101101110100000100000", + "10101110010001001101101010110110010010010101010001001110110111010000010000100", + "101011100100010011011010101101100100100101010100010011101101110100000100001010", + "10101110010001001101101010110110010010010101010001001110110111010000010000101100", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110100", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101010", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101100", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011010", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110000", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100010", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001100", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110100", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101010", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101110", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111110", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111110", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111110", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111110", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111110", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111000", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110010", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111111100110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011110", + "101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111111100111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001111110", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011111110", + "1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001111111100", + "10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011111111010", + }, +}, diff --git a/test/data/range-min-cover/mincover_double.cstruct b/test/data/range-min-cover/mincover_double.cstruct index b525ebcc5..0e46f90ab 100644 --- a/test/data/range-min-cover/mincover_double.cstruct +++ b/test/data/range-min-cover/mincover_double.cstruct @@ -1,2752 +1,3277 @@ -// This is a copy of test vectors from the mongodb/mongo repository. -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = -100.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "0011111110100111000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = -100.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "0011111110100111000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = -100.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "0011111110100111000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = -100.000000, - .includeUpperBound = true, - .sparsity = 8, - .expectMincoverString = "0011111110100111000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = -1.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "0011111110100111\n" \ - "0011111110101\n" \ - "001111111011\n" \ - "0011111111\n" \ - "010000000000\n" \ - "0100000000010000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = -1.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "0011111110100111\n" \ - "00111111101010\n" \ - "00111111101011\n" \ - "001111111011\n" \ - "0011111111\n" \ - "010000000000\n" \ - "0100000000010000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = -1.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "0011111110100111\n" \ - "0011111110101000\n" \ - "0011111110101001\n" \ - "0011111110101010\n" \ - "0011111110101011\n" \ - "0011111110101100\n" \ - "0011111110101101\n" \ - "0011111110101110\n" \ - "0011111110101111\n" \ - "001111111011\n" \ - "001111111100\n" \ - "001111111101\n" \ - "001111111110\n" \ - "001111111111\n" \ - "010000000000\n" \ - "0100000000010000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 0.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "0011111110100111\n" \ - "0011111110101\n" \ - "001111111011\n" \ - "0011111111\n" \ - "01\n" \ - "1000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 0.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "0011111110100111\n" \ - "00111111101010\n" \ - "00111111101011\n" \ - "001111111011\n" \ - "0011111111\n" \ - "01\n" \ - "1000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 0.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "0011111110100111\n" \ - "0011111110101000\n" \ - "0011111110101001\n" \ - "0011111110101010\n" \ - "0011111110101011\n" \ - "0011111110101100\n" \ - "0011111110101101\n" \ - "0011111110101110\n" \ - "0011111110101111\n" \ - "001111111011\n" \ - "001111111100\n" \ - "001111111101\n" \ - "001111111110\n" \ - "001111111111\n" \ - "0100\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "1000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 7.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "0011111110100111\n" \ - "0011111110101\n" \ - "001111111011\n" \ - "0011111111\n" \ - "01\n" \ - "10\n" \ - "110000000000\n" \ - "1100000000010\n" \ - "11000000000110\n" \ - "1100000000011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 7.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "0011111110100111\n" \ - "00111111101010\n" \ - "00111111101011\n" \ - "001111111011\n" \ - "0011111111\n" \ - "01\n" \ - "10\n" \ - "110000000000\n" \ - "11000000000100\n" \ - "11000000000101\n" \ - "11000000000110\n" \ - "1100000000011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 7.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "0011111110100111\n" \ - "0011111110101000\n" \ - "0011111110101001\n" \ - "0011111110101010\n" \ - "0011111110101011\n" \ - "0011111110101100\n" \ - "0011111110101101\n" \ - "0011111110101110\n" \ - "0011111110101111\n" \ - "001111111011\n" \ - "001111111100\n" \ - "001111111101\n" \ - "001111111110\n" \ - "001111111111\n" \ - "0100\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "1000\n" \ - "1001\n" \ - "1010\n" \ - "1011\n" \ - "110000000000\n" \ - "1100000000010000\n" \ - "1100000000010001\n" \ - "1100000000010010\n" \ - "1100000000010011\n" \ - "1100000000010100\n" \ - "1100000000010101\n" \ - "1100000000010110\n" \ - "1100000000010111\n" \ - "1100000000011000\n" \ - "1100000000011001\n" \ - "1100000000011010\n" \ - "1100000000011011\n" \ - "1100000000011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "0011111110100111\n" \ - "0011111110101\n" \ - "001111111011\n" \ - "0011111111\n" \ - "01\n" \ - "10\n" \ - "1100000000\n" \ - "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "0011111110100111\n" \ - "00111111101010\n" \ - "00111111101011\n" \ - "001111111011\n" \ - "0011111111\n" \ - "01\n" \ - "10\n" \ - "1100000000\n" \ - "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "0011111110100111\n" \ - "0011111110101000\n" \ - "0011111110101001\n" \ - "0011111110101010\n" \ - "0011111110101011\n" \ - "0011111110101100\n" \ - "0011111110101101\n" \ - "0011111110101110\n" \ - "0011111110101111\n" \ - "001111111011\n" \ - "001111111100\n" \ - "001111111101\n" \ - "001111111110\n" \ - "001111111111\n" \ - "0100\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "1000\n" \ - "1001\n" \ - "1010\n" \ - "1011\n" \ - "110000000000\n" \ - "110000000001\n" \ - "110000000010\n" \ - "110000000011\n" \ - "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "0011111110100111\n" \ - "0011111110101\n" \ - "001111111011\n" \ - "0011111111\n" \ - "01\n" \ - "10\n" \ - "110000000\n" \ - "1100000010000\n" \ - "11000000100010\n" \ - "110000001000110\n" \ - "1100000010001110\n" \ - "11000000100011110\n" \ - "110000001000111110\n" \ - "1100000010001111110\n" \ - "11000000100011111110\n" \ - "110000001000111111110\n" \ - "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "0011111110100111\n" \ - "00111111101010\n" \ - "00111111101011\n" \ - "001111111011\n" \ - "0011111111\n" \ - "01\n" \ - "10\n" \ - "1100000000\n" \ - "1100000001\n" \ - "11000000100000\n" \ - "11000000100001\n" \ - "11000000100010\n" \ - "1100000010001100\n" \ - "1100000010001101\n" \ - "1100000010001110\n" \ - "110000001000111100\n" \ - "110000001000111101\n" \ - "110000001000111110\n" \ - "11000000100011111100\n" \ - "11000000100011111101\n" \ - "11000000100011111110\n" \ - "1100000010001111111100\n" \ - "1100000010001111111101\n" \ - "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "0011111110100111\n" \ - "0011111110101\n" \ - "001111111011\n" \ - "0011111111\n" \ - "01\n" \ - "10\n" \ - "110000000\n" \ - "11000000100\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "0011111110100111\n" \ - "00111111101010\n" \ - "00111111101011\n" \ - "001111111011\n" \ - "0011111111\n" \ - "01\n" \ - "10\n" \ - "1100000000\n" \ - "1100000001\n" \ - "110000001000\n" \ - "110000001001\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "0011111110100111\n" \ - "0011111110101000\n" \ - "0011111110101001\n" \ - "0011111110101010\n" \ - "0011111110101011\n" \ - "0011111110101100\n" \ - "0011111110101101\n" \ - "0011111110101110\n" \ - "0011111110101111\n" \ - "001111111011\n" \ - "001111111100\n" \ - "001111111101\n" \ - "001111111110\n" \ - "001111111111\n" \ - "0100\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "1000\n" \ - "1001\n" \ - "1010\n" \ - "1011\n" \ - "110000000000\n" \ - "110000000001\n" \ - "110000000010\n" \ - "110000000011\n" \ - "110000000100\n" \ - "110000000101\n" \ - "110000000110\n" \ - "110000000111\n" \ - "110000001000\n" \ - "110000001001\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "0011111110100111\n" \ - "0011111110101\n" \ - "001111111011\n" \ - "0011111111\n" \ - "01\n" \ - "10\n" \ - "110000000\n" \ - "1100000010\n" \ - "11000000110\n" \ - "1100000011100\n" \ - "11000000111010\n" \ - "110000001110110\n" \ - "1100000011101110\n" \ - "11000000111011110\n" \ - "110000001110111110\n" \ - "1100000011101111110\n" \ - "11000000111011111110\n" \ - "110000001110111111110\n" \ - "1100000011101111111110\n" \ - "11000000111011111111110\n" \ - "110000001110111111111110\n" \ - "1100000011101111111111110\n" \ - "11000000111011111111111110\n" \ - "110000001110111111111111110\n" \ - "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "0011111110100111\n" \ - "00111111101010\n" \ - "00111111101011\n" \ - "001111111011\n" \ - "0011111111\n" \ - "01\n" \ - "10\n" \ - "1100000000\n" \ - "1100000001\n" \ - "1100000010\n" \ - "110000001100\n" \ - "110000001101\n" \ - "11000000111000\n" \ - "11000000111001\n" \ - "11000000111010\n" \ - "1100000011101100\n" \ - "1100000011101101\n" \ - "1100000011101110\n" \ - "110000001110111100\n" \ - "110000001110111101\n" \ - "110000001110111110\n" \ - "11000000111011111100\n" \ - "11000000111011111101\n" \ - "11000000111011111110\n" \ - "1100000011101111111100\n" \ - "1100000011101111111101\n" \ - "1100000011101111111110\n" \ - "110000001110111111111100\n" \ - "110000001110111111111101\n" \ - "110000001110111111111110\n" \ - "11000000111011111111111100\n" \ - "11000000111011111111111101\n" \ - "11000000111011111111111110\n" \ - "1100000011101111111111111100\n" \ - "1100000011101111111111111101\n" \ - "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "0011111110100111\n" \ - "0011111110101\n" \ - "001111111011\n" \ - "0011111111\n" \ - "01\n" \ - "10\n" \ - "11000000\n" \ - "110000010\n" \ - "1100000110\n" \ - "110000011100\n" \ - "1100000111010\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "0011111110100111\n" \ - "00111111101010\n" \ - "00111111101011\n" \ - "001111111011\n" \ - "0011111111\n" \ - "01\n" \ - "10\n" \ - "11000000\n" \ - "1100000100\n" \ - "1100000101\n" \ - "1100000110\n" \ - "110000011100\n" \ - "11000001110100\n" \ - "11000001110101\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -100.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "0011111110100111\n" \ - "0011111110101000\n" \ - "0011111110101001\n" \ - "0011111110101010\n" \ - "0011111110101011\n" \ - "0011111110101100\n" \ - "0011111110101101\n" \ - "0011111110101110\n" \ - "0011111110101111\n" \ - "001111111011\n" \ - "001111111100\n" \ - "001111111101\n" \ - "001111111110\n" \ - "001111111111\n" \ - "0100\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "1000\n" \ - "1001\n" \ - "1010\n" \ - "1011\n" \ - "11000000\n" \ - "110000010000\n" \ - "110000010001\n" \ - "110000010010\n" \ - "110000010011\n" \ - "110000010100\n" \ - "110000010101\n" \ - "110000010110\n" \ - "110000010111\n" \ - "110000011000\n" \ - "110000011001\n" \ - "110000011010\n" \ - "110000011011\n" \ - "110000011100\n" \ - "1100000111010000\n" \ - "1100000111010001\n" \ - "1100000111010010\n" \ - "1100000111010011\n" \ - "1100000111010100\n" \ - "1100000111010101\n" \ - "1100000111010110\n" \ - "1100000111010111\n" \ - "1100000111011000\n" \ - "1100000111011001\n" \ - "1100000111011010\n" \ - "1100000111011011\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = -1.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "0100000000010000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = -1.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "0100000000010000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = -1.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "0100000000010000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = -1.000000, - .includeUpperBound = true, - .sparsity = 8, - .expectMincoverString = "0100000000010000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 0.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "010000000001\n" \ - "01000000001\n" \ - "0100000001\n" \ - "010000001\n" \ - "01000001\n" \ - "0100001\n" \ - "010001\n" \ - "01001\n" \ - "0101\n" \ - "011\n" \ - "1000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 0.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "010000000001\n" \ - "010000000010\n" \ - "010000000011\n" \ - "0100000001\n" \ - "0100000010\n" \ - "0100000011\n" \ - "01000001\n" \ - "01000010\n" \ - "01000011\n" \ - "010001\n" \ - "010010\n" \ - "010011\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "1000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 0.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "010000000001\n" \ - "010000000010\n" \ - "010000000011\n" \ - "010000000100\n" \ - "010000000101\n" \ - "010000000110\n" \ - "010000000111\n" \ - "010000001000\n" \ - "010000001001\n" \ - "010000001010\n" \ - "010000001011\n" \ - "010000001100\n" \ - "010000001101\n" \ - "010000001110\n" \ - "010000001111\n" \ - "01000001\n" \ - "01000010\n" \ - "01000011\n" \ - "01000100\n" \ - "01000101\n" \ - "01000110\n" \ - "01000111\n" \ - "01001000\n" \ - "01001001\n" \ - "01001010\n" \ - "01001011\n" \ - "01001100\n" \ - "01001101\n" \ - "01001110\n" \ - "01001111\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "1000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 7.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "010000000001\n" \ - "01000000001\n" \ - "0100000001\n" \ - "010000001\n" \ - "01000001\n" \ - "0100001\n" \ - "010001\n" \ - "01001\n" \ - "0101\n" \ - "011\n" \ - "10\n" \ - "110000000000\n" \ - "1100000000010\n" \ - "11000000000110\n" \ - "1100000000011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 7.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "010000000001\n" \ - "010000000010\n" \ - "010000000011\n" \ - "0100000001\n" \ - "0100000010\n" \ - "0100000011\n" \ - "01000001\n" \ - "01000010\n" \ - "01000011\n" \ - "010001\n" \ - "010010\n" \ - "010011\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "10\n" \ - "110000000000\n" \ - "11000000000100\n" \ - "11000000000101\n" \ - "11000000000110\n" \ - "1100000000011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "010000000001\n" \ - "01000000001\n" \ - "0100000001\n" \ - "010000001\n" \ - "01000001\n" \ - "0100001\n" \ - "010001\n" \ - "01001\n" \ - "0101\n" \ - "011\n" \ - "10\n" \ - "1100000000\n" \ - "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "010000000001\n" \ - "010000000010\n" \ - "010000000011\n" \ - "0100000001\n" \ - "0100000010\n" \ - "0100000011\n" \ - "01000001\n" \ - "01000010\n" \ - "01000011\n" \ - "010001\n" \ - "010010\n" \ - "010011\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "10\n" \ - "1100000000\n" \ - "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "010000000001\n" \ - "010000000010\n" \ - "010000000011\n" \ - "010000000100\n" \ - "010000000101\n" \ - "010000000110\n" \ - "010000000111\n" \ - "010000001000\n" \ - "010000001001\n" \ - "010000001010\n" \ - "010000001011\n" \ - "010000001100\n" \ - "010000001101\n" \ - "010000001110\n" \ - "010000001111\n" \ - "01000001\n" \ - "01000010\n" \ - "01000011\n" \ - "01000100\n" \ - "01000101\n" \ - "01000110\n" \ - "01000111\n" \ - "01001000\n" \ - "01001001\n" \ - "01001010\n" \ - "01001011\n" \ - "01001100\n" \ - "01001101\n" \ - "01001110\n" \ - "01001111\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "1000\n" \ - "1001\n" \ - "1010\n" \ - "1011\n" \ - "110000000000\n" \ - "110000000001\n" \ - "110000000010\n" \ - "110000000011\n" \ - "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "010000000001\n" \ - "01000000001\n" \ - "0100000001\n" \ - "010000001\n" \ - "01000001\n" \ - "0100001\n" \ - "010001\n" \ - "01001\n" \ - "0101\n" \ - "011\n" \ - "10\n" \ - "110000000\n" \ - "1100000010000\n" \ - "11000000100010\n" \ - "110000001000110\n" \ - "1100000010001110\n" \ - "11000000100011110\n" \ - "110000001000111110\n" \ - "1100000010001111110\n" \ - "11000000100011111110\n" \ - "110000001000111111110\n" \ - "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "010000000001\n" \ - "010000000010\n" \ - "010000000011\n" \ - "0100000001\n" \ - "0100000010\n" \ - "0100000011\n" \ - "01000001\n" \ - "01000010\n" \ - "01000011\n" \ - "010001\n" \ - "010010\n" \ - "010011\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "10\n" \ - "1100000000\n" \ - "1100000001\n" \ - "11000000100000\n" \ - "11000000100001\n" \ - "11000000100010\n" \ - "1100000010001100\n" \ - "1100000010001101\n" \ - "1100000010001110\n" \ - "110000001000111100\n" \ - "110000001000111101\n" \ - "110000001000111110\n" \ - "11000000100011111100\n" \ - "11000000100011111101\n" \ - "11000000100011111110\n" \ - "1100000010001111111100\n" \ - "1100000010001111111101\n" \ - "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "010000000001\n" \ - "01000000001\n" \ - "0100000001\n" \ - "010000001\n" \ - "01000001\n" \ - "0100001\n" \ - "010001\n" \ - "01001\n" \ - "0101\n" \ - "011\n" \ - "10\n" \ - "110000000\n" \ - "11000000100\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "010000000001\n" \ - "010000000010\n" \ - "010000000011\n" \ - "0100000001\n" \ - "0100000010\n" \ - "0100000011\n" \ - "01000001\n" \ - "01000010\n" \ - "01000011\n" \ - "010001\n" \ - "010010\n" \ - "010011\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "10\n" \ - "1100000000\n" \ - "1100000001\n" \ - "110000001000\n" \ - "110000001001\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "010000000001\n" \ - "01000000001\n" \ - "0100000001\n" \ - "010000001\n" \ - "01000001\n" \ - "0100001\n" \ - "010001\n" \ - "01001\n" \ - "0101\n" \ - "011\n" \ - "10\n" \ - "110000000\n" \ - "1100000010\n" \ - "11000000110\n" \ - "1100000011100\n" \ - "11000000111010\n" \ - "110000001110110\n" \ - "1100000011101110\n" \ - "11000000111011110\n" \ - "110000001110111110\n" \ - "1100000011101111110\n" \ - "11000000111011111110\n" \ - "110000001110111111110\n" \ - "1100000011101111111110\n" \ - "11000000111011111111110\n" \ - "110000001110111111111110\n" \ - "1100000011101111111111110\n" \ - "11000000111011111111111110\n" \ - "110000001110111111111111110\n" \ - "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "010000000001\n" \ - "010000000010\n" \ - "010000000011\n" \ - "0100000001\n" \ - "0100000010\n" \ - "0100000011\n" \ - "01000001\n" \ - "01000010\n" \ - "01000011\n" \ - "010001\n" \ - "010010\n" \ - "010011\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "10\n" \ - "1100000000\n" \ - "1100000001\n" \ - "1100000010\n" \ - "110000001100\n" \ - "110000001101\n" \ - "11000000111000\n" \ - "11000000111001\n" \ - "11000000111010\n" \ - "1100000011101100\n" \ - "1100000011101101\n" \ - "1100000011101110\n" \ - "110000001110111100\n" \ - "110000001110111101\n" \ - "110000001110111110\n" \ - "11000000111011111100\n" \ - "11000000111011111101\n" \ - "11000000111011111110\n" \ - "1100000011101111111100\n" \ - "1100000011101111111101\n" \ - "1100000011101111111110\n" \ - "110000001110111111111100\n" \ - "110000001110111111111101\n" \ - "110000001110111111111110\n" \ - "11000000111011111111111100\n" \ - "11000000111011111111111101\n" \ - "11000000111011111111111110\n" \ - "1100000011101111111111111100\n" \ - "1100000011101111111111111101\n" \ - "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "010000000001\n" \ - "01000000001\n" \ - "0100000001\n" \ - "010000001\n" \ - "01000001\n" \ - "0100001\n" \ - "010001\n" \ - "01001\n" \ - "0101\n" \ - "011\n" \ - "10\n" \ - "11000000\n" \ - "110000010\n" \ - "1100000110\n" \ - "110000011100\n" \ - "1100000111010\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "010000000001\n" \ - "010000000010\n" \ - "010000000011\n" \ - "0100000001\n" \ - "0100000010\n" \ - "0100000011\n" \ - "01000001\n" \ - "01000010\n" \ - "01000011\n" \ - "010001\n" \ - "010010\n" \ - "010011\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "10\n" \ - "11000000\n" \ - "1100000100\n" \ - "1100000101\n" \ - "1100000110\n" \ - "110000011100\n" \ - "11000001110100\n" \ - "11000001110101\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 0.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "1000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 0.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 0.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 0.000000, - .includeUpperBound = true, - .sparsity = 8, - .expectMincoverString = "1000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 7.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "10\n" \ - "110000000000\n" \ - "1100000000010\n" \ - "11000000000110\n" \ - "1100000000011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 7.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "10\n" \ - "110000000000\n" \ - "11000000000100\n" \ - "11000000000101\n" \ - "11000000000110\n" \ - "1100000000011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 7.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1000\n" \ - "1001\n" \ - "1010\n" \ - "1011\n" \ - "110000000000\n" \ - "1100000000010000\n" \ - "1100000000010001\n" \ - "1100000000010010\n" \ - "1100000000010011\n" \ - "1100000000010100\n" \ - "1100000000010101\n" \ - "1100000000010110\n" \ - "1100000000010111\n" \ - "1100000000011000\n" \ - "1100000000011001\n" \ - "1100000000011010\n" \ - "1100000000011011\n" \ - "1100000000011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "10\n" \ - "1100000000\n" \ - "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "10\n" \ - "1100000000\n" \ - "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1000\n" \ - "1001\n" \ - "1010\n" \ - "1011\n" \ - "110000000000\n" \ - "110000000001\n" \ - "110000000010\n" \ - "110000000011\n" \ - "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "10\n" \ - "110000000\n" \ - "1100000010000\n" \ - "11000000100010\n" \ - "110000001000110\n" \ - "1100000010001110\n" \ - "11000000100011110\n" \ - "110000001000111110\n" \ - "1100000010001111110\n" \ - "11000000100011111110\n" \ - "110000001000111111110\n" \ - "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "10\n" \ - "1100000000\n" \ - "1100000001\n" \ - "11000000100000\n" \ - "11000000100001\n" \ - "11000000100010\n" \ - "1100000010001100\n" \ - "1100000010001101\n" \ - "1100000010001110\n" \ - "110000001000111100\n" \ - "110000001000111101\n" \ - "110000001000111110\n" \ - "11000000100011111100\n" \ - "11000000100011111101\n" \ - "11000000100011111110\n" \ - "1100000010001111111100\n" \ - "1100000010001111111101\n" \ - "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "10\n" \ - "110000000\n" \ - "11000000100\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "10\n" \ - "1100000000\n" \ - "1100000001\n" \ - "110000001000\n" \ - "110000001001\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1000\n" \ - "1001\n" \ - "1010\n" \ - "1011\n" \ - "110000000000\n" \ - "110000000001\n" \ - "110000000010\n" \ - "110000000011\n" \ - "110000000100\n" \ - "110000000101\n" \ - "110000000110\n" \ - "110000000111\n" \ - "110000001000\n" \ - "110000001001\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "10\n" \ - "110000000\n" \ - "1100000010\n" \ - "11000000110\n" \ - "1100000011100\n" \ - "11000000111010\n" \ - "110000001110110\n" \ - "1100000011101110\n" \ - "11000000111011110\n" \ - "110000001110111110\n" \ - "1100000011101111110\n" \ - "11000000111011111110\n" \ - "110000001110111111110\n" \ - "1100000011101111111110\n" \ - "11000000111011111111110\n" \ - "110000001110111111111110\n" \ - "1100000011101111111111110\n" \ - "11000000111011111111111110\n" \ - "110000001110111111111111110\n" \ - "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "10\n" \ - "1100000000\n" \ - "1100000001\n" \ - "1100000010\n" \ - "110000001100\n" \ - "110000001101\n" \ - "11000000111000\n" \ - "11000000111001\n" \ - "11000000111010\n" \ - "1100000011101100\n" \ - "1100000011101101\n" \ - "1100000011101110\n" \ - "110000001110111100\n" \ - "110000001110111101\n" \ - "110000001110111110\n" \ - "11000000111011111100\n" \ - "11000000111011111101\n" \ - "11000000111011111110\n" \ - "1100000011101111111100\n" \ - "1100000011101111111101\n" \ - "1100000011101111111110\n" \ - "110000001110111111111100\n" \ - "110000001110111111111101\n" \ - "110000001110111111111110\n" \ - "11000000111011111111111100\n" \ - "11000000111011111111111101\n" \ - "11000000111011111111111110\n" \ - "1100000011101111111111111100\n" \ - "1100000011101111111111111101\n" \ - "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "10\n" \ - "11000000\n" \ - "110000010\n" \ - "1100000110\n" \ - "110000011100\n" \ - "1100000111010\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "10\n" \ - "11000000\n" \ - "1100000100\n" \ - "1100000101\n" \ - "1100000110\n" \ - "110000011100\n" \ - "11000001110100\n" \ - "11000001110101\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1000\n" \ - "1001\n" \ - "1010\n" \ - "1011\n" \ - "11000000\n" \ - "110000010000\n" \ - "110000010001\n" \ - "110000010010\n" \ - "110000010011\n" \ - "110000010100\n" \ - "110000010101\n" \ - "110000010110\n" \ - "110000010111\n" \ - "110000011000\n" \ - "110000011001\n" \ - "110000011010\n" \ - "110000011011\n" \ - "110000011100\n" \ - "1100000111010000\n" \ - "1100000111010001\n" \ - "1100000111010010\n" \ - "1100000111010011\n" \ - "1100000111010100\n" \ - "1100000111010101\n" \ - "1100000111010110\n" \ - "1100000111010111\n" \ - "1100000111011000\n" \ - "1100000111011001\n" \ - "1100000111011010\n" \ - "1100000111011011\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 7.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "1100000000011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 7.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1100000000011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 7.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1100000000011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 7.000000, - .includeUpperBound = true, - .sparsity = 8, - .expectMincoverString = "1100000000011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "11000000000111\n" \ - "11000000001\n" \ - "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "11000000000111\n" \ - "110000000010\n" \ - "110000000011\n" \ - "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1100000000011100\n" \ - "1100000000011101\n" \ - "1100000000011110\n" \ - "1100000000011111\n" \ - "110000000010\n" \ - "110000000011\n" \ - "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 8, - .expectMincoverString = "1100000000011100\n" \ - "1100000000011101\n" \ - "1100000000011110\n" \ - "1100000000011111\n" \ - "1100000000100000\n" \ - "1100000000100001\n" \ - "1100000000100010\n" \ - "1100000000100011\n" \ - "1100000000100100\n" \ - "1100000000100101\n" \ - "1100000000100110\n" \ - "1100000000100111\n" \ - "1100000000101000\n" \ - "1100000000101001\n" \ - "1100000000101010\n" \ - "1100000000101011\n" \ - "1100000000101100\n" \ - "1100000000101101\n" \ - "1100000000101110\n" \ - "1100000000101111\n" \ - "1100000000110000\n" \ - "1100000000110001\n" \ - "1100000000110010\n" \ - "1100000000110011\n" \ - "1100000000110100\n" \ - "1100000000110101\n" \ - "1100000000110110\n" \ - "1100000000110111\n" \ - "1100000000111000\n" \ - "1100000000111001\n" \ - "1100000000111010\n" \ - "1100000000111011\n" \ - "1100000000111100\n" \ - "1100000000111101\n" \ - "1100000000111110\n" \ - "1100000000111111\n" \ - "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "11000000000111\n" \ - "11000000001\n" \ - "1100000001\n" \ - "1100000010000\n" \ - "11000000100010\n" \ - "110000001000110\n" \ - "1100000010001110\n" \ - "11000000100011110\n" \ - "110000001000111110\n" \ - "1100000010001111110\n" \ - "11000000100011111110\n" \ - "110000001000111111110\n" \ - "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "11000000000111\n" \ - "110000000010\n" \ - "110000000011\n" \ - "1100000001\n" \ - "11000000100000\n" \ - "11000000100001\n" \ - "11000000100010\n" \ - "1100000010001100\n" \ - "1100000010001101\n" \ - "1100000010001110\n" \ - "110000001000111100\n" \ - "110000001000111101\n" \ - "110000001000111110\n" \ - "11000000100011111100\n" \ - "11000000100011111101\n" \ - "11000000100011111110\n" \ - "1100000010001111111100\n" \ - "1100000010001111111101\n" \ - "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1100000000011100\n" \ - "1100000000011101\n" \ - "1100000000011110\n" \ - "1100000000011111\n" \ - "110000000010\n" \ - "110000000011\n" \ - "110000000100\n" \ - "110000000101\n" \ - "110000000110\n" \ - "110000000111\n" \ - "1100000010000000\n" \ - "1100000010000001\n" \ - "1100000010000010\n" \ - "1100000010000011\n" \ - "1100000010000100\n" \ - "1100000010000101\n" \ - "1100000010000110\n" \ - "1100000010000111\n" \ - "1100000010001000\n" \ - "1100000010001001\n" \ - "1100000010001010\n" \ - "1100000010001011\n" \ - "1100000010001100\n" \ - "1100000010001101\n" \ - "1100000010001110\n" \ - "11000000100011110000\n" \ - "11000000100011110001\n" \ - "11000000100011110010\n" \ - "11000000100011110011\n" \ - "11000000100011110100\n" \ - "11000000100011110101\n" \ - "11000000100011110110\n" \ - "11000000100011110111\n" \ - "11000000100011111000\n" \ - "11000000100011111001\n" \ - "11000000100011111010\n" \ - "11000000100011111011\n" \ - "11000000100011111100\n" \ - "11000000100011111101\n" \ - "11000000100011111110\n" \ - "110000001000111111110000\n" \ - "110000001000111111110001\n" \ - "110000001000111111110010\n" \ - "110000001000111111110011\n" \ - "110000001000111111110100\n" \ - "110000001000111111110101\n" \ - "110000001000111111110110\n" \ - "110000001000111111110111\n" \ - "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "11000000000111\n" \ - "11000000001\n" \ - "1100000001\n" \ - "11000000100\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "11000000000111\n" \ - "110000000010\n" \ - "110000000011\n" \ - "1100000001\n" \ - "110000001000\n" \ - "110000001001\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1100000000011100\n" \ - "1100000000011101\n" \ - "1100000000011110\n" \ - "1100000000011111\n" \ - "110000000010\n" \ - "110000000011\n" \ - "110000000100\n" \ - "110000000101\n" \ - "110000000110\n" \ - "110000000111\n" \ - "110000001000\n" \ - "110000001001\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "11000000000111\n" \ - "11000000001\n" \ - "1100000001\n" \ - "1100000010\n" \ - "11000000110\n" \ - "1100000011100\n" \ - "11000000111010\n" \ - "110000001110110\n" \ - "1100000011101110\n" \ - "11000000111011110\n" \ - "110000001110111110\n" \ - "1100000011101111110\n" \ - "11000000111011111110\n" \ - "110000001110111111110\n" \ - "1100000011101111111110\n" \ - "11000000111011111111110\n" \ - "110000001110111111111110\n" \ - "1100000011101111111111110\n" \ - "11000000111011111111111110\n" \ - "110000001110111111111111110\n" \ - "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "11000000000111\n" \ - "110000000010\n" \ - "110000000011\n" \ - "1100000001\n" \ - "1100000010\n" \ - "110000001100\n" \ - "110000001101\n" \ - "11000000111000\n" \ - "11000000111001\n" \ - "11000000111010\n" \ - "1100000011101100\n" \ - "1100000011101101\n" \ - "1100000011101110\n" \ - "110000001110111100\n" \ - "110000001110111101\n" \ - "110000001110111110\n" \ - "11000000111011111100\n" \ - "11000000111011111101\n" \ - "11000000111011111110\n" \ - "1100000011101111111100\n" \ - "1100000011101111111101\n" \ - "1100000011101111111110\n" \ - "110000001110111111111100\n" \ - "110000001110111111111101\n" \ - "110000001110111111111110\n" \ - "11000000111011111111111100\n" \ - "11000000111011111111111101\n" \ - "11000000111011111111111110\n" \ - "1100000011101111111111111100\n" \ - "1100000011101111111111111101\n" \ - "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "11000000000111\n" \ - "11000000001\n" \ - "1100000001\n" \ - "110000001\n" \ - "110000010\n" \ - "1100000110\n" \ - "110000011100\n" \ - "1100000111010\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "11000000000111\n" \ - "110000000010\n" \ - "110000000011\n" \ - "1100000001\n" \ - "1100000010\n" \ - "1100000011\n" \ - "1100000100\n" \ - "1100000101\n" \ - "1100000110\n" \ - "110000011100\n" \ - "11000001110100\n" \ - "11000001110101\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 7.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1100000000011100\n" \ - "1100000000011101\n" \ - "1100000000011110\n" \ - "1100000000011111\n" \ - "110000000010\n" \ - "110000000011\n" \ - "110000000100\n" \ - "110000000101\n" \ - "110000000110\n" \ - "110000000111\n" \ - "110000001000\n" \ - "110000001001\n" \ - "110000001010\n" \ - "110000001011\n" \ - "110000001100\n" \ - "110000001101\n" \ - "110000001110\n" \ - "110000001111\n" \ - "110000010000\n" \ - "110000010001\n" \ - "110000010010\n" \ - "110000010011\n" \ - "110000010100\n" \ - "110000010101\n" \ - "110000010110\n" \ - "110000010111\n" \ - "110000011000\n" \ - "110000011001\n" \ - "110000011010\n" \ - "110000011011\n" \ - "110000011100\n" \ - "1100000111010000\n" \ - "1100000111010001\n" \ - "1100000111010010\n" \ - "1100000111010011\n" \ - "1100000111010100\n" \ - "1100000111010101\n" \ - "1100000111010110\n" \ - "1100000111010111\n" \ - "1100000111011000\n" \ - "1100000111011001\n" \ - "1100000111011010\n" \ - "1100000111011011\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 32.000000, - .includeUpperBound = true, - .sparsity = 8, - .expectMincoverString = "1100000001000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "1100000001\n" \ - "1100000010000\n" \ - "11000000100010\n" \ - "110000001000110\n" \ - "1100000010001110\n" \ - "11000000100011110\n" \ - "110000001000111110\n" \ - "1100000010001111110\n" \ - "11000000100011111110\n" \ - "110000001000111111110\n" \ - "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1100000001\n" \ - "11000000100000\n" \ - "11000000100001\n" \ - "11000000100010\n" \ - "1100000010001100\n" \ - "1100000010001101\n" \ - "1100000010001110\n" \ - "110000001000111100\n" \ - "110000001000111101\n" \ - "110000001000111110\n" \ - "11000000100011111100\n" \ - "11000000100011111101\n" \ - "11000000100011111110\n" \ - "1100000010001111111100\n" \ - "1100000010001111111101\n" \ - "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "110000000100\n" \ - "110000000101\n" \ - "110000000110\n" \ - "110000000111\n" \ - "1100000010000000\n" \ - "1100000010000001\n" \ - "1100000010000010\n" \ - "1100000010000011\n" \ - "1100000010000100\n" \ - "1100000010000101\n" \ - "1100000010000110\n" \ - "1100000010000111\n" \ - "1100000010001000\n" \ - "1100000010001001\n" \ - "1100000010001010\n" \ - "1100000010001011\n" \ - "1100000010001100\n" \ - "1100000010001101\n" \ - "1100000010001110\n" \ - "11000000100011110000\n" \ - "11000000100011110001\n" \ - "11000000100011110010\n" \ - "11000000100011110011\n" \ - "11000000100011110100\n" \ - "11000000100011110101\n" \ - "11000000100011110110\n" \ - "11000000100011110111\n" \ - "11000000100011111000\n" \ - "11000000100011111001\n" \ - "11000000100011111010\n" \ - "11000000100011111011\n" \ - "11000000100011111100\n" \ - "11000000100011111101\n" \ - "11000000100011111110\n" \ - "110000001000111111110000\n" \ - "110000001000111111110001\n" \ - "110000001000111111110010\n" \ - "110000001000111111110011\n" \ - "110000001000111111110100\n" \ - "110000001000111111110101\n" \ - "110000001000111111110110\n" \ - "110000001000111111110111\n" \ - "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "1100000001\n" \ - "11000000100\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1100000001\n" \ - "110000001000\n" \ - "110000001001\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "110000000100\n" \ - "110000000101\n" \ - "110000000110\n" \ - "110000000111\n" \ - "110000001000\n" \ - "110000001001\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "1100000001\n" \ - "1100000010\n" \ - "11000000110\n" \ - "1100000011100\n" \ - "11000000111010\n" \ - "110000001110110\n" \ - "1100000011101110\n" \ - "11000000111011110\n" \ - "110000001110111110\n" \ - "1100000011101111110\n" \ - "11000000111011111110\n" \ - "110000001110111111110\n" \ - "1100000011101111111110\n" \ - "11000000111011111111110\n" \ - "110000001110111111111110\n" \ - "1100000011101111111111110\n" \ - "11000000111011111111111110\n" \ - "110000001110111111111111110\n" \ - "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1100000001\n" \ - "1100000010\n" \ - "110000001100\n" \ - "110000001101\n" \ - "11000000111000\n" \ - "11000000111001\n" \ - "11000000111010\n" \ - "1100000011101100\n" \ - "1100000011101101\n" \ - "1100000011101110\n" \ - "110000001110111100\n" \ - "110000001110111101\n" \ - "110000001110111110\n" \ - "11000000111011111100\n" \ - "11000000111011111101\n" \ - "11000000111011111110\n" \ - "1100000011101111111100\n" \ - "1100000011101111111101\n" \ - "1100000011101111111110\n" \ - "110000001110111111111100\n" \ - "110000001110111111111101\n" \ - "110000001110111111111110\n" \ - "11000000111011111111111100\n" \ - "11000000111011111111111101\n" \ - "11000000111011111111111110\n" \ - "1100000011101111111111111100\n" \ - "1100000011101111111111111101\n" \ - "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "1100000001\n" \ - "110000001\n" \ - "110000010\n" \ - "1100000110\n" \ - "110000011100\n" \ - "1100000111010\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1100000001\n" \ - "1100000010\n" \ - "1100000011\n" \ - "1100000100\n" \ - "1100000101\n" \ - "1100000110\n" \ - "110000011100\n" \ - "11000001110100\n" \ - "11000001110101\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 32.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "110000000100\n" \ - "110000000101\n" \ - "110000000110\n" \ - "110000000111\n" \ - "110000001000\n" \ - "110000001001\n" \ - "110000001010\n" \ - "110000001011\n" \ - "110000001100\n" \ - "110000001101\n" \ - "110000001110\n" \ - "110000001111\n" \ - "110000010000\n" \ - "110000010001\n" \ - "110000010010\n" \ - "110000010011\n" \ - "110000010100\n" \ - "110000010101\n" \ - "110000010110\n" \ - "110000010111\n" \ - "110000011000\n" \ - "110000011001\n" \ - "110000011010\n" \ - "110000011011\n" \ - "110000011100\n" \ - "1100000111010000\n" \ - "1100000111010001\n" \ - "1100000111010010\n" \ - "1100000111010011\n" \ - "1100000111010100\n" \ - "1100000111010101\n" \ - "1100000111010110\n" \ - "1100000111010111\n" \ - "1100000111011000\n" \ - "1100000111011001\n" \ - "1100000111011010\n" \ - "1100000111011011\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1023.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1023.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1023.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1023.000000, - .includeLowerBound = true, - .upperBound = 1023.000000, - .includeUpperBound = true, - .sparsity = 8, - .expectMincoverString = "1100000010001111111110000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1023.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "110000001000111111111\n" \ - "110000001001\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1023.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1100000010001111111110\n" \ - "1100000010001111111111\n" \ - "110000001001\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1023.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "110000001000111111111000\n" \ - "110000001000111111111001\n" \ - "110000001000111111111010\n" \ - "110000001000111111111011\n" \ - "110000001000111111111100\n" \ - "110000001000111111111101\n" \ - "110000001000111111111110\n" \ - "110000001000111111111111\n" \ - "110000001001\n" \ - "110000001010\n" \ - "1100000010110000\n" \ - "11000000101100010000\n" \ - "110000001011000100010000\n" \ - "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1023.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "110000001000111111111\n" \ - "110000001001\n" \ - "11000000101\n" \ - "11000000110\n" \ - "1100000011100\n" \ - "11000000111010\n" \ - "110000001110110\n" \ - "1100000011101110\n" \ - "11000000111011110\n" \ - "110000001110111110\n" \ - "1100000011101111110\n" \ - "11000000111011111110\n" \ - "110000001110111111110\n" \ - "1100000011101111111110\n" \ - "11000000111011111111110\n" \ - "110000001110111111111110\n" \ - "1100000011101111111111110\n" \ - "11000000111011111111111110\n" \ - "110000001110111111111111110\n" \ - "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1023.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1100000010001111111110\n" \ - "1100000010001111111111\n" \ - "110000001001\n" \ - "110000001010\n" \ - "110000001011\n" \ - "110000001100\n" \ - "110000001101\n" \ - "11000000111000\n" \ - "11000000111001\n" \ - "11000000111010\n" \ - "1100000011101100\n" \ - "1100000011101101\n" \ - "1100000011101110\n" \ - "110000001110111100\n" \ - "110000001110111101\n" \ - "110000001110111110\n" \ - "11000000111011111100\n" \ - "11000000111011111101\n" \ - "11000000111011111110\n" \ - "1100000011101111111100\n" \ - "1100000011101111111101\n" \ - "1100000011101111111110\n" \ - "110000001110111111111100\n" \ - "110000001110111111111101\n" \ - "110000001110111111111110\n" \ - "11000000111011111111111100\n" \ - "11000000111011111111111101\n" \ - "11000000111011111111111110\n" \ - "1100000011101111111111111100\n" \ - "1100000011101111111111111101\n" \ - "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1023.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "110000001000111111111\n" \ - "110000001001\n" \ - "11000000101\n" \ - "1100000011\n" \ - "110000010\n" \ - "1100000110\n" \ - "110000011100\n" \ - "1100000111010\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1023.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1100000010001111111110\n" \ - "1100000010001111111111\n" \ - "110000001001\n" \ - "110000001010\n" \ - "110000001011\n" \ - "1100000011\n" \ - "1100000100\n" \ - "1100000101\n" \ - "1100000110\n" \ - "110000011100\n" \ - "11000001110100\n" \ - "11000001110101\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1023.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "110000001000111111111000\n" \ - "110000001000111111111001\n" \ - "110000001000111111111010\n" \ - "110000001000111111111011\n" \ - "110000001000111111111100\n" \ - "110000001000111111111101\n" \ - "110000001000111111111110\n" \ - "110000001000111111111111\n" \ - "110000001001\n" \ - "110000001010\n" \ - "110000001011\n" \ - "110000001100\n" \ - "110000001101\n" \ - "110000001110\n" \ - "110000001111\n" \ - "110000010000\n" \ - "110000010001\n" \ - "110000010010\n" \ - "110000010011\n" \ - "110000010100\n" \ - "110000010101\n" \ - "110000010110\n" \ - "110000010111\n" \ - "110000011000\n" \ - "110000011001\n" \ - "110000011010\n" \ - "110000011011\n" \ - "110000011100\n" \ - "1100000111010000\n" \ - "1100000111010001\n" \ - "1100000111010010\n" \ - "1100000111010011\n" \ - "1100000111010100\n" \ - "1100000111010101\n" \ - "1100000111010110\n" \ - "1100000111010111\n" \ - "1100000111011000\n" \ - "1100000111011001\n" \ - "1100000111011010\n" \ - "1100000111011011\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 4369.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 4369.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 4369.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 4369.000000, - .includeLowerBound = true, - .upperBound = 4369.000000, - .includeUpperBound = true, - .sparsity = 8, - .expectMincoverString = "1100000010110001000100010000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 4369.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "110000001011000100010001\n" \ - "11000000101100010001001\n" \ - "1100000010110001000101\n" \ - "110000001011000100011\n" \ - "1100000010110001001\n" \ - "110000001011000101\n" \ - "11000000101100011\n" \ - "110000001011001\n" \ - "11000000101101\n" \ - "1100000010111\n" \ - "11000000110\n" \ - "1100000011100\n" \ - "11000000111010\n" \ - "110000001110110\n" \ - "1100000011101110\n" \ - "11000000111011110\n" \ - "110000001110111110\n" \ - "1100000011101111110\n" \ - "11000000111011111110\n" \ - "110000001110111111110\n" \ - "1100000011101111111110\n" \ - "11000000111011111111110\n" \ - "110000001110111111111110\n" \ - "1100000011101111111111110\n" \ - "11000000111011111111111110\n" \ - "110000001110111111111111110\n" \ - "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 4369.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "110000001011000100010001\n" \ - "110000001011000100010010\n" \ - "110000001011000100010011\n" \ - "1100000010110001000101\n" \ - "1100000010110001000110\n" \ - "1100000010110001000111\n" \ - "11000000101100010010\n" \ - "11000000101100010011\n" \ - "110000001011000101\n" \ - "110000001011000110\n" \ - "110000001011000111\n" \ - "1100000010110010\n" \ - "1100000010110011\n" \ - "11000000101101\n" \ - "11000000101110\n" \ - "11000000101111\n" \ - "110000001100\n" \ - "110000001101\n" \ - "11000000111000\n" \ - "11000000111001\n" \ - "11000000111010\n" \ - "1100000011101100\n" \ - "1100000011101101\n" \ - "1100000011101110\n" \ - "110000001110111100\n" \ - "110000001110111101\n" \ - "110000001110111110\n" \ - "11000000111011111100\n" \ - "11000000111011111101\n" \ - "11000000111011111110\n" \ - "1100000011101111111100\n" \ - "1100000011101111111101\n" \ - "1100000011101111111110\n" \ - "110000001110111111111100\n" \ - "110000001110111111111101\n" \ - "110000001110111111111110\n" \ - "11000000111011111111111100\n" \ - "11000000111011111111111101\n" \ - "11000000111011111111111110\n" \ - "1100000011101111111111111100\n" \ - "1100000011101111111111111101\n" \ - "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 4369.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "110000001011000100010001\n" \ - "11000000101100010001001\n" \ - "1100000010110001000101\n" \ - "110000001011000100011\n" \ - "1100000010110001001\n" \ - "110000001011000101\n" \ - "11000000101100011\n" \ - "110000001011001\n" \ - "11000000101101\n" \ - "1100000010111\n" \ - "1100000011\n" \ - "110000010\n" \ - "1100000110\n" \ - "110000011100\n" \ - "1100000111010\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 4369.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "110000001011000100010001\n" \ - "110000001011000100010010\n" \ - "110000001011000100010011\n" \ - "1100000010110001000101\n" \ - "1100000010110001000110\n" \ - "1100000010110001000111\n" \ - "11000000101100010010\n" \ - "11000000101100010011\n" \ - "110000001011000101\n" \ - "110000001011000110\n" \ - "110000001011000111\n" \ - "1100000010110010\n" \ - "1100000010110011\n" \ - "11000000101101\n" \ - "11000000101110\n" \ - "11000000101111\n" \ - "1100000011\n" \ - "1100000100\n" \ - "1100000101\n" \ - "1100000110\n" \ - "110000011100\n" \ - "11000001110100\n" \ - "11000001110101\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 65535.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 65535.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 65535.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 65535.000000, - .includeLowerBound = true, - .upperBound = 65535.000000, - .includeUpperBound = true, - .sparsity = 8, - .expectMincoverString = "1100000011101111111111111110000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 65535.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "110000001110111111111111111\n" \ - "110000001111\n" \ - "110000010\n" \ - "1100000110\n" \ - "110000011100\n" \ - "1100000111010\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 65535.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1100000011101111111111111110\n" \ - "1100000011101111111111111111\n" \ - "110000001111\n" \ - "1100000100\n" \ - "1100000101\n" \ - "1100000110\n" \ - "110000011100\n" \ - "11000001110100\n" \ - "11000001110101\n" \ - "11000001110110\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 65535.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1100000011101111111111111110\n" \ - "1100000011101111111111111111\n" \ - "110000001111\n" \ - "110000010000\n" \ - "110000010001\n" \ - "110000010010\n" \ - "110000010011\n" \ - "110000010100\n" \ - "110000010101\n" \ - "110000010110\n" \ - "110000010111\n" \ - "110000011000\n" \ - "110000011001\n" \ - "110000011010\n" \ - "110000011011\n" \ - "110000011100\n" \ - "1100000111010000\n" \ - "1100000111010001\n" \ - "1100000111010010\n" \ - "1100000111010011\n" \ - "1100000111010100\n" \ - "1100000111010101\n" \ - "1100000111010110\n" \ - "1100000111010111\n" \ - "1100000111011000\n" \ - "1100000111011001\n" \ - "1100000111011010\n" \ - "1100000111011011\n" \ - "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1879048192.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 1, - .expectMincoverString = "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1879048192.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 2, - .expectMincoverString = "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1879048192.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 4, - .expectMincoverString = "1100000111011100000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1879048192.000000, - .includeLowerBound = true, - .upperBound = 1879048192.000000, - .includeUpperBound = true, - .sparsity = 8, - .expectMincoverString = "1100000111011100000000000000000000000000000000000000000000000000\n" +// This code is GENERATED! Do not edit! +// clang-format off +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = -100.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = -100.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = -100.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = -100.000000, + .includeUpperBound = true, + .sparsity = 8, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = -1.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "0011111110101", + "001111111011", + "0011111111", + "010000000000", + "0100000000010000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = -1.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "00111111101010", + "00111111101011", + "001111111011", + "0011111111", + "010000000000", + "0100000000010000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = -1.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "0011111110101000", + "0011111110101001", + "0011111110101010", + "0011111110101011", + "0011111110101100", + "0011111110101101", + "0011111110101110", + "0011111110101111", + "001111111011", + "001111111100", + "001111111101", + "001111111110", + "001111111111", + "010000000000", + "0100000000010000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 0.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "0011111110101", + "001111111011", + "0011111111", + "01", + "1000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 0.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "00111111101010", + "00111111101011", + "001111111011", + "0011111111", + "01", + "1000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 0.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "0011111110101000", + "0011111110101001", + "0011111110101010", + "0011111110101011", + "0011111110101100", + "0011111110101101", + "0011111110101110", + "0011111110101111", + "001111111011", + "001111111100", + "001111111101", + "001111111110", + "001111111111", + "0100", + "0101", + "0110", + "0111", + "1000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 7.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "0011111110101", + "001111111011", + "0011111111", + "01", + "10", + "110000000000", + "1100000000010", + "11000000000110", + "1100000000011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 7.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "00111111101010", + "00111111101011", + "001111111011", + "0011111111", + "01", + "10", + "110000000000", + "11000000000100", + "11000000000101", + "11000000000110", + "1100000000011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 7.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "0011111110101000", + "0011111110101001", + "0011111110101010", + "0011111110101011", + "0011111110101100", + "0011111110101101", + "0011111110101110", + "0011111110101111", + "001111111011", + "001111111100", + "001111111101", + "001111111110", + "001111111111", + "0100", + "0101", + "0110", + "0111", + "1000", + "1001", + "1010", + "1011", + "110000000000", + "1100000000010000", + "1100000000010001", + "1100000000010010", + "1100000000010011", + "1100000000010100", + "1100000000010101", + "1100000000010110", + "1100000000010111", + "1100000000011000", + "1100000000011001", + "1100000000011010", + "1100000000011011", + "1100000000011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "0011111110101", + "001111111011", + "0011111111", + "01", + "10", + "1100000000", + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "00111111101010", + "00111111101011", + "001111111011", + "0011111111", + "01", + "10", + "1100000000", + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "0011111110101000", + "0011111110101001", + "0011111110101010", + "0011111110101011", + "0011111110101100", + "0011111110101101", + "0011111110101110", + "0011111110101111", + "001111111011", + "001111111100", + "001111111101", + "001111111110", + "001111111111", + "0100", + "0101", + "0110", + "0111", + "1000", + "1001", + "1010", + "1011", + "110000000000", + "110000000001", + "110000000010", + "110000000011", + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "0011111110101", + "001111111011", + "0011111111", + "01", + "10", + "110000000", + "1100000010000", + "11000000100010", + "110000001000110", + "1100000010001110", + "11000000100011110", + "110000001000111110", + "1100000010001111110", + "11000000100011111110", + "110000001000111111110", + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "00111111101010", + "00111111101011", + "001111111011", + "0011111111", + "01", + "10", + "1100000000", + "1100000001", + "11000000100000", + "11000000100001", + "11000000100010", + "1100000010001100", + "1100000010001101", + "1100000010001110", + "110000001000111100", + "110000001000111101", + "110000001000111110", + "11000000100011111100", + "11000000100011111101", + "11000000100011111110", + "1100000010001111111100", + "1100000010001111111101", + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "0011111110101", + "001111111011", + "0011111111", + "01", + "10", + "110000000", + "11000000100", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "00111111101010", + "00111111101011", + "001111111011", + "0011111111", + "01", + "10", + "1100000000", + "1100000001", + "110000001000", + "110000001001", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "0011111110101000", + "0011111110101001", + "0011111110101010", + "0011111110101011", + "0011111110101100", + "0011111110101101", + "0011111110101110", + "0011111110101111", + "001111111011", + "001111111100", + "001111111101", + "001111111110", + "001111111111", + "0100", + "0101", + "0110", + "0111", + "1000", + "1001", + "1010", + "1011", + "110000000000", + "110000000001", + "110000000010", + "110000000011", + "110000000100", + "110000000101", + "110000000110", + "110000000111", + "110000001000", + "110000001001", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "0011111110101", + "001111111011", + "0011111111", + "01", + "10", + "110000000", + "1100000010", + "11000000110", + "1100000011100", + "11000000111010", + "110000001110110", + "1100000011101110", + "11000000111011110", + "110000001110111110", + "1100000011101111110", + "11000000111011111110", + "110000001110111111110", + "1100000011101111111110", + "11000000111011111111110", + "110000001110111111111110", + "1100000011101111111111110", + "11000000111011111111111110", + "110000001110111111111111110", + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "00111111101010", + "00111111101011", + "001111111011", + "0011111111", + "01", + "10", + "1100000000", + "1100000001", + "1100000010", + "110000001100", + "110000001101", + "11000000111000", + "11000000111001", + "11000000111010", + "1100000011101100", + "1100000011101101", + "1100000011101110", + "110000001110111100", + "110000001110111101", + "110000001110111110", + "11000000111011111100", + "11000000111011111101", + "11000000111011111110", + "1100000011101111111100", + "1100000011101111111101", + "1100000011101111111110", + "110000001110111111111100", + "110000001110111111111101", + "110000001110111111111110", + "11000000111011111111111100", + "11000000111011111111111101", + "11000000111011111111111110", + "1100000011101111111111111100", + "1100000011101111111111111101", + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "0011111110101", + "001111111011", + "0011111111", + "01", + "10", + "11000000", + "110000010", + "1100000110", + "110000011100", + "1100000111010", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "00111111101010", + "00111111101011", + "001111111011", + "0011111111", + "01", + "10", + "11000000", + "1100000100", + "1100000101", + "1100000110", + "110000011100", + "11000001110100", + "11000001110101", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -100.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0011111110100111", + "0011111110101000", + "0011111110101001", + "0011111110101010", + "0011111110101011", + "0011111110101100", + "0011111110101101", + "0011111110101110", + "0011111110101111", + "001111111011", + "001111111100", + "001111111101", + "001111111110", + "001111111111", + "0100", + "0101", + "0110", + "0111", + "1000", + "1001", + "1010", + "1011", + "11000000", + "110000010000", + "110000010001", + "110000010010", + "110000010011", + "110000010100", + "110000010101", + "110000010110", + "110000010111", + "110000011000", + "110000011001", + "110000011010", + "110000011011", + "110000011100", + "1100000111010000", + "1100000111010001", + "1100000111010010", + "1100000111010011", + "1100000111010100", + "1100000111010101", + "1100000111010110", + "1100000111010111", + "1100000111011000", + "1100000111011001", + "1100000111011010", + "1100000111011011", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = -1.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0100000000010000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = -1.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0100000000010000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = -1.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0100000000010000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = -1.000000, + .includeUpperBound = true, + .sparsity = 8, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "0100000000010000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 0.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "01000000001", + "0100000001", + "010000001", + "01000001", + "0100001", + "010001", + "01001", + "0101", + "011", + "1000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 0.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "010000000010", + "010000000011", + "0100000001", + "0100000010", + "0100000011", + "01000001", + "01000010", + "01000011", + "010001", + "010010", + "010011", + "0101", + "0110", + "0111", + "1000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 0.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "010000000010", + "010000000011", + "010000000100", + "010000000101", + "010000000110", + "010000000111", + "010000001000", + "010000001001", + "010000001010", + "010000001011", + "010000001100", + "010000001101", + "010000001110", + "010000001111", + "01000001", + "01000010", + "01000011", + "01000100", + "01000101", + "01000110", + "01000111", + "01001000", + "01001001", + "01001010", + "01001011", + "01001100", + "01001101", + "01001110", + "01001111", + "0101", + "0110", + "0111", + "1000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 7.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "01000000001", + "0100000001", + "010000001", + "01000001", + "0100001", + "010001", + "01001", + "0101", + "011", + "10", + "110000000000", + "1100000000010", + "11000000000110", + "1100000000011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 7.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "010000000010", + "010000000011", + "0100000001", + "0100000010", + "0100000011", + "01000001", + "01000010", + "01000011", + "010001", + "010010", + "010011", + "0101", + "0110", + "0111", + "10", + "110000000000", + "11000000000100", + "11000000000101", + "11000000000110", + "1100000000011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "01000000001", + "0100000001", + "010000001", + "01000001", + "0100001", + "010001", + "01001", + "0101", + "011", + "10", + "1100000000", + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "010000000010", + "010000000011", + "0100000001", + "0100000010", + "0100000011", + "01000001", + "01000010", + "01000011", + "010001", + "010010", + "010011", + "0101", + "0110", + "0111", + "10", + "1100000000", + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "010000000010", + "010000000011", + "010000000100", + "010000000101", + "010000000110", + "010000000111", + "010000001000", + "010000001001", + "010000001010", + "010000001011", + "010000001100", + "010000001101", + "010000001110", + "010000001111", + "01000001", + "01000010", + "01000011", + "01000100", + "01000101", + "01000110", + "01000111", + "01001000", + "01001001", + "01001010", + "01001011", + "01001100", + "01001101", + "01001110", + "01001111", + "0101", + "0110", + "0111", + "1000", + "1001", + "1010", + "1011", + "110000000000", + "110000000001", + "110000000010", + "110000000011", + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "01000000001", + "0100000001", + "010000001", + "01000001", + "0100001", + "010001", + "01001", + "0101", + "011", + "10", + "110000000", + "1100000010000", + "11000000100010", + "110000001000110", + "1100000010001110", + "11000000100011110", + "110000001000111110", + "1100000010001111110", + "11000000100011111110", + "110000001000111111110", + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "010000000010", + "010000000011", + "0100000001", + "0100000010", + "0100000011", + "01000001", + "01000010", + "01000011", + "010001", + "010010", + "010011", + "0101", + "0110", + "0111", + "10", + "1100000000", + "1100000001", + "11000000100000", + "11000000100001", + "11000000100010", + "1100000010001100", + "1100000010001101", + "1100000010001110", + "110000001000111100", + "110000001000111101", + "110000001000111110", + "11000000100011111100", + "11000000100011111101", + "11000000100011111110", + "1100000010001111111100", + "1100000010001111111101", + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "01000000001", + "0100000001", + "010000001", + "01000001", + "0100001", + "010001", + "01001", + "0101", + "011", + "10", + "110000000", + "11000000100", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "010000000010", + "010000000011", + "0100000001", + "0100000010", + "0100000011", + "01000001", + "01000010", + "01000011", + "010001", + "010010", + "010011", + "0101", + "0110", + "0111", + "10", + "1100000000", + "1100000001", + "110000001000", + "110000001001", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "01000000001", + "0100000001", + "010000001", + "01000001", + "0100001", + "010001", + "01001", + "0101", + "011", + "10", + "110000000", + "1100000010", + "11000000110", + "1100000011100", + "11000000111010", + "110000001110110", + "1100000011101110", + "11000000111011110", + "110000001110111110", + "1100000011101111110", + "11000000111011111110", + "110000001110111111110", + "1100000011101111111110", + "11000000111011111111110", + "110000001110111111111110", + "1100000011101111111111110", + "11000000111011111111111110", + "110000001110111111111111110", + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "010000000010", + "010000000011", + "0100000001", + "0100000010", + "0100000011", + "01000001", + "01000010", + "01000011", + "010001", + "010010", + "010011", + "0101", + "0110", + "0111", + "10", + "1100000000", + "1100000001", + "1100000010", + "110000001100", + "110000001101", + "11000000111000", + "11000000111001", + "11000000111010", + "1100000011101100", + "1100000011101101", + "1100000011101110", + "110000001110111100", + "110000001110111101", + "110000001110111110", + "11000000111011111100", + "11000000111011111101", + "11000000111011111110", + "1100000011101111111100", + "1100000011101111111101", + "1100000011101111111110", + "110000001110111111111100", + "110000001110111111111101", + "110000001110111111111110", + "11000000111011111111111100", + "11000000111011111111111101", + "11000000111011111111111110", + "1100000011101111111111111100", + "1100000011101111111111111101", + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "01000000001", + "0100000001", + "010000001", + "01000001", + "0100001", + "010001", + "01001", + "0101", + "011", + "10", + "11000000", + "110000010", + "1100000110", + "110000011100", + "1100000111010", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "010000000001", + "010000000010", + "010000000011", + "0100000001", + "0100000010", + "0100000011", + "01000001", + "01000010", + "01000011", + "010001", + "010010", + "010011", + "0101", + "0110", + "0111", + "10", + "11000000", + "1100000100", + "1100000101", + "1100000110", + "110000011100", + "11000001110100", + "11000001110101", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 0.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 0.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 0.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 0.000000, + .includeUpperBound = true, + .sparsity = 8, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 7.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "10", + "110000000000", + "1100000000010", + "11000000000110", + "1100000000011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 7.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "10", + "110000000000", + "11000000000100", + "11000000000101", + "11000000000110", + "1100000000011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 7.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1000", + "1001", + "1010", + "1011", + "110000000000", + "1100000000010000", + "1100000000010001", + "1100000000010010", + "1100000000010011", + "1100000000010100", + "1100000000010101", + "1100000000010110", + "1100000000010111", + "1100000000011000", + "1100000000011001", + "1100000000011010", + "1100000000011011", + "1100000000011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "10", + "1100000000", + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "10", + "1100000000", + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1000", + "1001", + "1010", + "1011", + "110000000000", + "110000000001", + "110000000010", + "110000000011", + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "10", + "110000000", + "1100000010000", + "11000000100010", + "110000001000110", + "1100000010001110", + "11000000100011110", + "110000001000111110", + "1100000010001111110", + "11000000100011111110", + "110000001000111111110", + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "10", + "1100000000", + "1100000001", + "11000000100000", + "11000000100001", + "11000000100010", + "1100000010001100", + "1100000010001101", + "1100000010001110", + "110000001000111100", + "110000001000111101", + "110000001000111110", + "11000000100011111100", + "11000000100011111101", + "11000000100011111110", + "1100000010001111111100", + "1100000010001111111101", + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "10", + "110000000", + "11000000100", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "10", + "1100000000", + "1100000001", + "110000001000", + "110000001001", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1000", + "1001", + "1010", + "1011", + "110000000000", + "110000000001", + "110000000010", + "110000000011", + "110000000100", + "110000000101", + "110000000110", + "110000000111", + "110000001000", + "110000001001", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "10", + "110000000", + "1100000010", + "11000000110", + "1100000011100", + "11000000111010", + "110000001110110", + "1100000011101110", + "11000000111011110", + "110000001110111110", + "1100000011101111110", + "11000000111011111110", + "110000001110111111110", + "1100000011101111111110", + "11000000111011111111110", + "110000001110111111111110", + "1100000011101111111111110", + "11000000111011111111111110", + "110000001110111111111111110", + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "10", + "1100000000", + "1100000001", + "1100000010", + "110000001100", + "110000001101", + "11000000111000", + "11000000111001", + "11000000111010", + "1100000011101100", + "1100000011101101", + "1100000011101110", + "110000001110111100", + "110000001110111101", + "110000001110111110", + "11000000111011111100", + "11000000111011111101", + "11000000111011111110", + "1100000011101111111100", + "1100000011101111111101", + "1100000011101111111110", + "110000001110111111111100", + "110000001110111111111101", + "110000001110111111111110", + "11000000111011111111111100", + "11000000111011111111111101", + "11000000111011111111111110", + "1100000011101111111111111100", + "1100000011101111111111111101", + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "10", + "11000000", + "110000010", + "1100000110", + "110000011100", + "1100000111010", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "10", + "11000000", + "1100000100", + "1100000101", + "1100000110", + "110000011100", + "11000001110100", + "11000001110101", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1000", + "1001", + "1010", + "1011", + "11000000", + "110000010000", + "110000010001", + "110000010010", + "110000010011", + "110000010100", + "110000010101", + "110000010110", + "110000010111", + "110000011000", + "110000011001", + "110000011010", + "110000011011", + "110000011100", + "1100000111010000", + "1100000111010001", + "1100000111010010", + "1100000111010011", + "1100000111010100", + "1100000111010101", + "1100000111010110", + "1100000111010111", + "1100000111011000", + "1100000111011001", + "1100000111011010", + "1100000111011011", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 7.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000000011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 7.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000000011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 7.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000000011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 7.000000, + .includeUpperBound = true, + .sparsity = 8, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000000011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "11000000000111", + "11000000001", + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "11000000000111", + "110000000010", + "110000000011", + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000000011100", + "1100000000011101", + "1100000000011110", + "1100000000011111", + "110000000010", + "110000000011", + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 8, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000000011100", + "1100000000011101", + "1100000000011110", + "1100000000011111", + "1100000000100000", + "1100000000100001", + "1100000000100010", + "1100000000100011", + "1100000000100100", + "1100000000100101", + "1100000000100110", + "1100000000100111", + "1100000000101000", + "1100000000101001", + "1100000000101010", + "1100000000101011", + "1100000000101100", + "1100000000101101", + "1100000000101110", + "1100000000101111", + "1100000000110000", + "1100000000110001", + "1100000000110010", + "1100000000110011", + "1100000000110100", + "1100000000110101", + "1100000000110110", + "1100000000110111", + "1100000000111000", + "1100000000111001", + "1100000000111010", + "1100000000111011", + "1100000000111100", + "1100000000111101", + "1100000000111110", + "1100000000111111", + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "11000000000111", + "11000000001", + "1100000001", + "1100000010000", + "11000000100010", + "110000001000110", + "1100000010001110", + "11000000100011110", + "110000001000111110", + "1100000010001111110", + "11000000100011111110", + "110000001000111111110", + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "11000000000111", + "110000000010", + "110000000011", + "1100000001", + "11000000100000", + "11000000100001", + "11000000100010", + "1100000010001100", + "1100000010001101", + "1100000010001110", + "110000001000111100", + "110000001000111101", + "110000001000111110", + "11000000100011111100", + "11000000100011111101", + "11000000100011111110", + "1100000010001111111100", + "1100000010001111111101", + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000000011100", + "1100000000011101", + "1100000000011110", + "1100000000011111", + "110000000010", + "110000000011", + "110000000100", + "110000000101", + "110000000110", + "110000000111", + "1100000010000000", + "1100000010000001", + "1100000010000010", + "1100000010000011", + "1100000010000100", + "1100000010000101", + "1100000010000110", + "1100000010000111", + "1100000010001000", + "1100000010001001", + "1100000010001010", + "1100000010001011", + "1100000010001100", + "1100000010001101", + "1100000010001110", + "11000000100011110000", + "11000000100011110001", + "11000000100011110010", + "11000000100011110011", + "11000000100011110100", + "11000000100011110101", + "11000000100011110110", + "11000000100011110111", + "11000000100011111000", + "11000000100011111001", + "11000000100011111010", + "11000000100011111011", + "11000000100011111100", + "11000000100011111101", + "11000000100011111110", + "110000001000111111110000", + "110000001000111111110001", + "110000001000111111110010", + "110000001000111111110011", + "110000001000111111110100", + "110000001000111111110101", + "110000001000111111110110", + "110000001000111111110111", + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "11000000000111", + "11000000001", + "1100000001", + "11000000100", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "11000000000111", + "110000000010", + "110000000011", + "1100000001", + "110000001000", + "110000001001", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000000011100", + "1100000000011101", + "1100000000011110", + "1100000000011111", + "110000000010", + "110000000011", + "110000000100", + "110000000101", + "110000000110", + "110000000111", + "110000001000", + "110000001001", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "11000000000111", + "11000000001", + "1100000001", + "1100000010", + "11000000110", + "1100000011100", + "11000000111010", + "110000001110110", + "1100000011101110", + "11000000111011110", + "110000001110111110", + "1100000011101111110", + "11000000111011111110", + "110000001110111111110", + "1100000011101111111110", + "11000000111011111111110", + "110000001110111111111110", + "1100000011101111111111110", + "11000000111011111111111110", + "110000001110111111111111110", + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "11000000000111", + "110000000010", + "110000000011", + "1100000001", + "1100000010", + "110000001100", + "110000001101", + "11000000111000", + "11000000111001", + "11000000111010", + "1100000011101100", + "1100000011101101", + "1100000011101110", + "110000001110111100", + "110000001110111101", + "110000001110111110", + "11000000111011111100", + "11000000111011111101", + "11000000111011111110", + "1100000011101111111100", + "1100000011101111111101", + "1100000011101111111110", + "110000001110111111111100", + "110000001110111111111101", + "110000001110111111111110", + "11000000111011111111111100", + "11000000111011111111111101", + "11000000111011111111111110", + "1100000011101111111111111100", + "1100000011101111111111111101", + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "11000000000111", + "11000000001", + "1100000001", + "110000001", + "110000010", + "1100000110", + "110000011100", + "1100000111010", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "11000000000111", + "110000000010", + "110000000011", + "1100000001", + "1100000010", + "1100000011", + "1100000100", + "1100000101", + "1100000110", + "110000011100", + "11000001110100", + "11000001110101", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000000011100", + "1100000000011101", + "1100000000011110", + "1100000000011111", + "110000000010", + "110000000011", + "110000000100", + "110000000101", + "110000000110", + "110000000111", + "110000001000", + "110000001001", + "110000001010", + "110000001011", + "110000001100", + "110000001101", + "110000001110", + "110000001111", + "110000010000", + "110000010001", + "110000010010", + "110000010011", + "110000010100", + "110000010101", + "110000010110", + "110000010111", + "110000011000", + "110000011001", + "110000011010", + "110000011011", + "110000011100", + "1100000111010000", + "1100000111010001", + "1100000111010010", + "1100000111010011", + "1100000111010100", + "1100000111010101", + "1100000111010110", + "1100000111010111", + "1100000111011000", + "1100000111011001", + "1100000111011010", + "1100000111011011", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 32.000000, + .includeUpperBound = true, + .sparsity = 8, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000001000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000001", + "1100000010000", + "11000000100010", + "110000001000110", + "1100000010001110", + "11000000100011110", + "110000001000111110", + "1100000010001111110", + "11000000100011111110", + "110000001000111111110", + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000001", + "11000000100000", + "11000000100001", + "11000000100010", + "1100000010001100", + "1100000010001101", + "1100000010001110", + "110000001000111100", + "110000001000111101", + "110000001000111110", + "11000000100011111100", + "11000000100011111101", + "11000000100011111110", + "1100000010001111111100", + "1100000010001111111101", + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "110000000100", + "110000000101", + "110000000110", + "110000000111", + "1100000010000000", + "1100000010000001", + "1100000010000010", + "1100000010000011", + "1100000010000100", + "1100000010000101", + "1100000010000110", + "1100000010000111", + "1100000010001000", + "1100000010001001", + "1100000010001010", + "1100000010001011", + "1100000010001100", + "1100000010001101", + "1100000010001110", + "11000000100011110000", + "11000000100011110001", + "11000000100011110010", + "11000000100011110011", + "11000000100011110100", + "11000000100011110101", + "11000000100011110110", + "11000000100011110111", + "11000000100011111000", + "11000000100011111001", + "11000000100011111010", + "11000000100011111011", + "11000000100011111100", + "11000000100011111101", + "11000000100011111110", + "110000001000111111110000", + "110000001000111111110001", + "110000001000111111110010", + "110000001000111111110011", + "110000001000111111110100", + "110000001000111111110101", + "110000001000111111110110", + "110000001000111111110111", + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000001", + "11000000100", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000001", + "110000001000", + "110000001001", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "110000000100", + "110000000101", + "110000000110", + "110000000111", + "110000001000", + "110000001001", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000001", + "1100000010", + "11000000110", + "1100000011100", + "11000000111010", + "110000001110110", + "1100000011101110", + "11000000111011110", + "110000001110111110", + "1100000011101111110", + "11000000111011111110", + "110000001110111111110", + "1100000011101111111110", + "11000000111011111111110", + "110000001110111111111110", + "1100000011101111111111110", + "11000000111011111111111110", + "110000001110111111111111110", + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000001", + "1100000010", + "110000001100", + "110000001101", + "11000000111000", + "11000000111001", + "11000000111010", + "1100000011101100", + "1100000011101101", + "1100000011101110", + "110000001110111100", + "110000001110111101", + "110000001110111110", + "11000000111011111100", + "11000000111011111101", + "11000000111011111110", + "1100000011101111111100", + "1100000011101111111101", + "1100000011101111111110", + "110000001110111111111100", + "110000001110111111111101", + "110000001110111111111110", + "11000000111011111111111100", + "11000000111011111111111101", + "11000000111011111111111110", + "1100000011101111111111111100", + "1100000011101111111111111101", + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000001", + "110000001", + "110000010", + "1100000110", + "110000011100", + "1100000111010", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000001", + "1100000010", + "1100000011", + "1100000100", + "1100000101", + "1100000110", + "110000011100", + "11000001110100", + "11000001110101", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "110000000100", + "110000000101", + "110000000110", + "110000000111", + "110000001000", + "110000001001", + "110000001010", + "110000001011", + "110000001100", + "110000001101", + "110000001110", + "110000001111", + "110000010000", + "110000010001", + "110000010010", + "110000010011", + "110000010100", + "110000010101", + "110000010110", + "110000010111", + "110000011000", + "110000011001", + "110000011010", + "110000011011", + "110000011100", + "1100000111010000", + "1100000111010001", + "1100000111010010", + "1100000111010011", + "1100000111010100", + "1100000111010101", + "1100000111010110", + "1100000111010111", + "1100000111011000", + "1100000111011001", + "1100000111011010", + "1100000111011011", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1023.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1023.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1023.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1023.000000, + .includeLowerBound = true, + .upperBound = 1023.000000, + .includeUpperBound = true, + .sparsity = 8, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000010001111111110000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1023.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "110000001000111111111", + "110000001001", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1023.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000010001111111110", + "1100000010001111111111", + "110000001001", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1023.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "110000001000111111111000", + "110000001000111111111001", + "110000001000111111111010", + "110000001000111111111011", + "110000001000111111111100", + "110000001000111111111101", + "110000001000111111111110", + "110000001000111111111111", + "110000001001", + "110000001010", + "1100000010110000", + "11000000101100010000", + "110000001011000100010000", + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1023.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "110000001000111111111", + "110000001001", + "11000000101", + "11000000110", + "1100000011100", + "11000000111010", + "110000001110110", + "1100000011101110", + "11000000111011110", + "110000001110111110", + "1100000011101111110", + "11000000111011111110", + "110000001110111111110", + "1100000011101111111110", + "11000000111011111111110", + "110000001110111111111110", + "1100000011101111111111110", + "11000000111011111111111110", + "110000001110111111111111110", + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1023.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000010001111111110", + "1100000010001111111111", + "110000001001", + "110000001010", + "110000001011", + "110000001100", + "110000001101", + "11000000111000", + "11000000111001", + "11000000111010", + "1100000011101100", + "1100000011101101", + "1100000011101110", + "110000001110111100", + "110000001110111101", + "110000001110111110", + "11000000111011111100", + "11000000111011111101", + "11000000111011111110", + "1100000011101111111100", + "1100000011101111111101", + "1100000011101111111110", + "110000001110111111111100", + "110000001110111111111101", + "110000001110111111111110", + "11000000111011111111111100", + "11000000111011111111111101", + "11000000111011111111111110", + "1100000011101111111111111100", + "1100000011101111111111111101", + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1023.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "110000001000111111111", + "110000001001", + "11000000101", + "1100000011", + "110000010", + "1100000110", + "110000011100", + "1100000111010", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1023.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000010001111111110", + "1100000010001111111111", + "110000001001", + "110000001010", + "110000001011", + "1100000011", + "1100000100", + "1100000101", + "1100000110", + "110000011100", + "11000001110100", + "11000001110101", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1023.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "110000001000111111111000", + "110000001000111111111001", + "110000001000111111111010", + "110000001000111111111011", + "110000001000111111111100", + "110000001000111111111101", + "110000001000111111111110", + "110000001000111111111111", + "110000001001", + "110000001010", + "110000001011", + "110000001100", + "110000001101", + "110000001110", + "110000001111", + "110000010000", + "110000010001", + "110000010010", + "110000010011", + "110000010100", + "110000010101", + "110000010110", + "110000010111", + "110000011000", + "110000011001", + "110000011010", + "110000011011", + "110000011100", + "1100000111010000", + "1100000111010001", + "1100000111010010", + "1100000111010011", + "1100000111010100", + "1100000111010101", + "1100000111010110", + "1100000111010111", + "1100000111011000", + "1100000111011001", + "1100000111011010", + "1100000111011011", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 4369.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 4369.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 4369.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 4369.000000, + .includeLowerBound = true, + .upperBound = 4369.000000, + .includeUpperBound = true, + .sparsity = 8, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000010110001000100010000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 4369.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "110000001011000100010001", + "11000000101100010001001", + "1100000010110001000101", + "110000001011000100011", + "1100000010110001001", + "110000001011000101", + "11000000101100011", + "110000001011001", + "11000000101101", + "1100000010111", + "11000000110", + "1100000011100", + "11000000111010", + "110000001110110", + "1100000011101110", + "11000000111011110", + "110000001110111110", + "1100000011101111110", + "11000000111011111110", + "110000001110111111110", + "1100000011101111111110", + "11000000111011111111110", + "110000001110111111111110", + "1100000011101111111111110", + "11000000111011111111111110", + "110000001110111111111111110", + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 4369.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "110000001011000100010001", + "110000001011000100010010", + "110000001011000100010011", + "1100000010110001000101", + "1100000010110001000110", + "1100000010110001000111", + "11000000101100010010", + "11000000101100010011", + "110000001011000101", + "110000001011000110", + "110000001011000111", + "1100000010110010", + "1100000010110011", + "11000000101101", + "11000000101110", + "11000000101111", + "110000001100", + "110000001101", + "11000000111000", + "11000000111001", + "11000000111010", + "1100000011101100", + "1100000011101101", + "1100000011101110", + "110000001110111100", + "110000001110111101", + "110000001110111110", + "11000000111011111100", + "11000000111011111101", + "11000000111011111110", + "1100000011101111111100", + "1100000011101111111101", + "1100000011101111111110", + "110000001110111111111100", + "110000001110111111111101", + "110000001110111111111110", + "11000000111011111111111100", + "11000000111011111111111101", + "11000000111011111111111110", + "1100000011101111111111111100", + "1100000011101111111111111101", + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 4369.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "110000001011000100010001", + "11000000101100010001001", + "1100000010110001000101", + "110000001011000100011", + "1100000010110001001", + "110000001011000101", + "11000000101100011", + "110000001011001", + "11000000101101", + "1100000010111", + "1100000011", + "110000010", + "1100000110", + "110000011100", + "1100000111010", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 4369.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "110000001011000100010001", + "110000001011000100010010", + "110000001011000100010011", + "1100000010110001000101", + "1100000010110001000110", + "1100000010110001000111", + "11000000101100010010", + "11000000101100010011", + "110000001011000101", + "110000001011000110", + "110000001011000111", + "1100000010110010", + "1100000010110011", + "11000000101101", + "11000000101110", + "11000000101111", + "1100000011", + "1100000100", + "1100000101", + "1100000110", + "110000011100", + "11000001110100", + "11000001110101", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 65535.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 65535.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 65535.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 65535.000000, + .includeLowerBound = true, + .upperBound = 65535.000000, + .includeUpperBound = true, + .sparsity = 8, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000011101111111111111110000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 65535.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "110000001110111111111111111", + "110000001111", + "110000010", + "1100000110", + "110000011100", + "1100000111010", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 65535.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000011101111111111111110", + "1100000011101111111111111111", + "110000001111", + "1100000100", + "1100000101", + "1100000110", + "110000011100", + "11000001110100", + "11000001110101", + "11000001110110", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 65535.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000011101111111111111110", + "1100000011101111111111111111", + "110000001111", + "110000010000", + "110000010001", + "110000010010", + "110000010011", + "110000010100", + "110000010101", + "110000010110", + "110000010111", + "110000011000", + "110000011001", + "110000011010", + "110000011011", + "110000011100", + "1100000111010000", + "1100000111010001", + "1100000111010010", + "1100000111010011", + "1100000111010100", + "1100000111010101", + "1100000111010110", + "1100000111010111", + "1100000111011000", + "1100000111011001", + "1100000111011010", + "1100000111011011", + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1879048192.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1879048192.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1879048192.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000111011100000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1879048192.000000, + .includeLowerBound = true, + .upperBound = 1879048192.000000, + .includeUpperBound = true, + .sparsity = 8, + .min = { .set = true, .value = -1000000000000000L }, + .max = { .set = true, .value = 0x7000000000000000L }, + .expectMincoverStrings = { + "1100000111011100000000000000000000000000000000000000000000000000", + }, }, diff --git a/test/data/range-min-cover/mincover_double_precision.cstruct b/test/data/range-min-cover/mincover_double_precision.cstruct index 2b3429660..f82e89d25 100644 --- a/test/data/range-min-cover/mincover_double_precision.cstruct +++ b/test/data/range-min-cover/mincover_double_precision.cstruct @@ -1,340 +1,369 @@ -// This is a copy of test vectors from the mongodb/mongo repository. +// This code is GENERATED! Do not edit! +// clang-format off { - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 1.638400, - .includeUpperBound = true, - .sparsity = 1, - .min = OPT_DOUBLE_C(0.000000), - .max = OPT_DOUBLE_C(6.500000), - .precision = OPT_U32_C(1), - .expectMincoverString = "000\n" \ - "0010000\n" + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 1.638400, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0.000000 }, + .max = { .set = true, .value = 6.500000 }, + .precision = { .set = true, .value = 1 }, + .expectMincoverStrings = { + "000", + "0010000", + }, }, { - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 1.638400, - .includeUpperBound = true, - .sparsity = 1, - .min = OPT_DOUBLE_C(0.000000), - .max = OPT_DOUBLE_C(6.550000), - .precision = OPT_U32_C(2), - .expectMincoverString = "000\n" \ - "00100\n" \ - "00101000\n" + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 1.638400, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0.000000 }, + .max = { .set = true, .value = 6.550000 }, + .precision = { .set = true, .value = 2 }, + .expectMincoverStrings = { + "000", + "00100", + "00101000", + }, }, { - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 1.638400, - .includeUpperBound = true, - .sparsity = 1, - .min = OPT_DOUBLE_C(0.000000), - .max = OPT_DOUBLE_C(6.553000), - .precision = OPT_U32_C(3), - .expectMincoverString = "000\n" \ - "0010\n" \ - "0011000\n" \ - "00110010\n" \ - "00110011000\n" \ - "001100110010\n" \ - "0011001100110\n" + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 1.638400, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0.000000 }, + .max = { .set = true, .value = 6.553000 }, + .precision = { .set = true, .value = 3 }, + .expectMincoverStrings = { + "000", + "0010", + "0011000", + "00110010", + "00110011000", + "001100110010", + "0011001100110", + }, }, { - .lowerBound = 0.000000, - .includeLowerBound = true, - .upperBound = 1.638400, - .includeUpperBound = true, - .sparsity = 1, - .min = OPT_DOUBLE_C(0.000000), - .max = OPT_DOUBLE_C(6.553600), - .precision = OPT_U32_C(4), - .expectMincoverString = "000\n" \ - "00100000000000000\n" + .lowerBound = 0.000000, + .includeLowerBound = true, + .upperBound = 1.638400, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0.000000 }, + .max = { .set = true, .value = 6.553600 }, + .precision = { .set = true, .value = 4 }, + .expectMincoverStrings = { + "000", + "00100000000000000", + }, }, { - .lowerBound = 10000.000000, - .includeLowerBound = true, - .upperBound = 20000.000000, - .includeUpperBound = true, - .sparsity = 1, - .min = OPT_DOUBLE_C(383.000000), - .max = OPT_DOUBLE_C(18446744073709552000.000000), - .precision = OPT_U32_C(0), - .expectMincoverString = "110000001100001110001\n" \ - "11000000110000111001\n" \ - "1100000011000011101\n" \ - "110000001100001111\n" \ - "11000000110001\n" \ - "1100000011001\n" \ - "110000001101000\n" \ - "1100000011010010\n" \ - "11000000110100110\n" \ - "110000001101001110000\n" \ - "1100000011010011100010000000000000000000000000000000000000000000\n" + .lowerBound = 10000.000000, + .includeLowerBound = true, + .upperBound = 20000.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 383.000000 }, + .max = { .set = true, .value = 18446744073709552000.000000 }, + .precision = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "110000001100001110001", + "11000000110000111001", + "1100000011000011101", + "110000001100001111", + "11000000110001", + "1100000011001", + "110000001101000", + "1100000011010010", + "11000000110100110", + "110000001101001110000", + "1100000011010011100010000000000000000000000000000000000000000000", + }, }, { - .lowerBound = 10000.000000, - .includeLowerBound = true, - .upperBound = 20000.000000, - .includeUpperBound = true, - .sparsity = 1, - .min = OPT_DOUBLE_C(384.000000), - .max = OPT_DOUBLE_C(18446744073709552000.000000), - .precision = OPT_U32_C(0), - .expectMincoverString = "110000001100001110001\n" \ - "11000000110000111001\n" \ - "1100000011000011101\n" \ - "110000001100001111\n" \ - "11000000110001\n" \ - "1100000011001\n" \ - "110000001101000\n" \ - "1100000011010010\n" \ - "11000000110100110\n" \ - "110000001101001110000\n" \ - "1100000011010011100010000000000000000000000000000000000000000000\n" + .lowerBound = 10000.000000, + .includeLowerBound = true, + .upperBound = 20000.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 384.000000 }, + .max = { .set = true, .value = 18446744073709552000.000000 }, + .precision = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "110000001100001110001", + "11000000110000111001", + "1100000011000011101", + "110000001100001111", + "11000000110001", + "1100000011001", + "110000001101000", + "1100000011010010", + "11000000110100110", + "110000001101001110000", + "1100000011010011100010000000000000000000000000000000000000000000", + }, }, { - .lowerBound = 13.000000, - .includeLowerBound = true, - .upperBound = 192.000000, - .includeUpperBound = true, - .sparsity = 1, - .min = OPT_DOUBLE_C(2.000000), - .max = OPT_DOUBLE_C(314.000000), - .precision = OPT_U32_C(0), - .expectMincoverString = "000001011\n" \ - "0000011\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "0100\n" \ - "01010\n" \ - "010110\n" \ - "0101110\n" \ - "01011110\n" \ - "010111110\n" + .lowerBound = 13.000000, + .includeLowerBound = true, + .upperBound = 192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 2.000000 }, + .max = { .set = true, .value = 314.000000 }, + .precision = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "000001011", + "0000011", + "00001", + "0001", + "001", + "0100", + "01010", + "010110", + "0101110", + "01011110", + "010111110", + }, }, { - .lowerBound = 13.000000, - .includeLowerBound = true, - .upperBound = 192.000000, - .includeUpperBound = true, - .sparsity = 1, - .min = OPT_DOUBLE_C(2.700000), - .max = OPT_DOUBLE_C(314.100000), - .precision = OPT_U32_C(1), - .expectMincoverString = "000001100111\n" \ - "000001101\n" \ - "00000111\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "010\n" \ - "0110\n" \ - "011100\n" \ - "0111010\n" \ - "0111011000\n" \ - "01110110010\n" + .lowerBound = 13.000000, + .includeLowerBound = true, + .upperBound = 192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 2.700000 }, + .max = { .set = true, .value = 314.100000 }, + .precision = { .set = true, .value = 1 }, + .expectMincoverStrings = { + "000001100111", + "000001101", + "00000111", + "00001", + "0001", + "001", + "010", + "0110", + "011100", + "0111010", + "0111011000", + "01110110010", + }, }, { - .lowerBound = 13.000000, - .includeLowerBound = true, - .upperBound = 192.000000, - .includeUpperBound = true, - .sparsity = 1, - .min = OPT_DOUBLE_C(2.710000), - .max = OPT_DOUBLE_C(314.150000), - .precision = OPT_U32_C(2), - .expectMincoverString = "000010000000101\n" \ - "00001000000011\n" \ - "000010000001\n" \ - "00001000001\n" \ - "0000100001\n" \ - "000010001\n" \ - "00001001\n" \ - "0000101\n" \ - "000011\n" \ - "0001\n" \ - "001\n" \ - "01\n" \ - "1000\n" \ - "1001000\n" \ - "10010010\n" \ - "100100110\n" \ - "1001001110\n" \ - "10010011110\n" \ - "10010011111000\n" + .lowerBound = 13.000000, + .includeLowerBound = true, + .upperBound = 192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 2.710000 }, + .max = { .set = true, .value = 314.150000 }, + .precision = { .set = true, .value = 2 }, + .expectMincoverStrings = { + "000010000000101", + "00001000000011", + "000010000001", + "00001000001", + "0000100001", + "000010001", + "00001001", + "0000101", + "000011", + "0001", + "001", + "01", + "1000", + "1001000", + "10010010", + "100100110", + "1001001110", + "10010011110", + "10010011111000", + }, }, { - .lowerBound = 13.000000, - .includeLowerBound = true, - .upperBound = 192.000000, - .includeUpperBound = true, - .sparsity = 1, - .min = OPT_DOUBLE_C(2.718000), - .max = OPT_DOUBLE_C(314.159000), - .precision = OPT_U32_C(3), - .expectMincoverString = "000001010000010101\n" \ - "00000101000001011\n" \ - "000001010000011\n" \ - "0000010100001\n" \ - "000001010001\n" \ - "00000101001\n" \ - "0000010101\n" \ - "000001011\n" \ - "0000011\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "0100\n" \ - "01010\n" \ - "010110\n" \ - "0101110000\n" \ - "01011100010\n" \ - "0101110001100\n" \ - "01011100011010\n" \ - "010111000110110000\n" \ - "0101110001101100010\n" + .lowerBound = 13.000000, + .includeLowerBound = true, + .upperBound = 192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 2.718000 }, + .max = { .set = true, .value = 314.159000 }, + .precision = { .set = true, .value = 3 }, + .expectMincoverStrings = { + "000001010000010101", + "00000101000001011", + "000001010000011", + "0000010100001", + "000001010001", + "00000101001", + "0000010101", + "000001011", + "0000011", + "00001", + "0001", + "001", + "0100", + "01010", + "010110", + "0101110000", + "01011100010", + "0101110001100", + "01011100011010", + "010111000110110000", + "0101110001101100010", + }, }, { - .lowerBound = 13.000000, - .includeLowerBound = true, - .upperBound = 192.000000, - .includeUpperBound = true, - .sparsity = 1, - .min = OPT_DOUBLE_C(2.718200), - .max = OPT_DOUBLE_C(314.159200), - .precision = OPT_U32_C(4), - .expectMincoverString = "000001100100011010001\n" \ - "00000110010001101001\n" \ - "0000011001000110101\n" \ - "000001100100011011\n" \ - "0000011001000111\n" \ - "0000011001001\n" \ - "000001100101\n" \ - "00000110011\n" \ - "000001101\n" \ - "00000111\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "010\n" \ - "0110\n" \ - "0111000\n" \ - "01110010\n" \ - "011100110\n" \ - "01110011100000\n" \ - "011100111000010\n" \ - "0111001110000110\n" \ - "011100111000011100\n" \ - "011100111000011101000\n" \ - "0111001110000111010010\n" + .lowerBound = 13.000000, + .includeLowerBound = true, + .upperBound = 192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 2.718200 }, + .max = { .set = true, .value = 314.159200 }, + .precision = { .set = true, .value = 4 }, + .expectMincoverStrings = { + "000001100100011010001", + "00000110010001101001", + "0000011001000110101", + "000001100100011011", + "0000011001000111", + "0000011001001", + "000001100101", + "00000110011", + "000001101", + "00000111", + "00001", + "0001", + "001", + "010", + "0110", + "0111000", + "01110010", + "011100110", + "01110011100000", + "011100111000010", + "0111001110000110", + "011100111000011100", + "011100111000011101000", + "0111001110000111010010", + }, }, { - .lowerBound = 13.000000, - .includeLowerBound = true, - .upperBound = 192.000000, - .includeUpperBound = true, - .sparsity = 1, - .min = OPT_DOUBLE_C(2.718280), - .max = OPT_DOUBLE_C(314.159260), - .precision = OPT_U32_C(5), - .expectMincoverString = "00000111110110000010011\n" \ - "000001111101100000101\n" \ - "00000111110110000011\n" \ - "000001111101100001\n" \ - "00000111110110001\n" \ - "0000011111011001\n" \ - "000001111101101\n" \ - "00000111110111\n" \ - "00000111111\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "01\n" \ - "1000\n" \ - "1001000000\n" \ - "10010000010\n" \ - "1001000001100\n" \ - "1001000001101000\n" \ - "10010000011010010000\n" \ - "1001000001101001000100\n" \ - "10010000011010010001010\n" \ - "1001000001101001000101100\n" + .lowerBound = 13.000000, + .includeLowerBound = true, + .upperBound = 192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 2.718280 }, + .max = { .set = true, .value = 314.159260 }, + .precision = { .set = true, .value = 5 }, + .expectMincoverStrings = { + "00000111110110000010011", + "000001111101100000101", + "00000111110110000011", + "000001111101100001", + "00000111110110001", + "0000011111011001", + "000001111101101", + "00000111110111", + "00000111111", + "00001", + "0001", + "001", + "01", + "1000", + "1001000000", + "10010000010", + "1001000001100", + "1001000001101000", + "10010000011010010000", + "1001000001101001000100", + "10010000011010010001010", + "1001000001101001000101100", + }, }, { - .lowerBound = 13.000000, - .includeLowerBound = true, - .upperBound = 192.000000, - .includeUpperBound = true, - .sparsity = 1, - .min = OPT_DOUBLE_C(2.718281), - .max = OPT_DOUBLE_C(314.159265), - .precision = OPT_U32_C(6), - .expectMincoverString = "0000010011100111000101111011\n" \ - "00000100111001110001011111\n" \ - "000001001110011100011\n" \ - "0000010011100111001\n" \ - "000001001110011101\n" \ - "00000100111001111\n" \ - "0000010011101\n" \ - "000001001111\n" \ - "00000101\n" \ - "0000011\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "0100\n" \ - "01010\n" \ - "0101100\n" \ - "0101101000\n" \ - "0101101001000000\n" \ - "01011010010000010\n" \ - "0101101001000001100\n" \ - "010110100100000110100\n" \ - "0101101001000001101010\n" \ - "010110100100000110101100\n" \ - "0101101001000001101011010\n" \ - "01011010010000011010110110\n" + .lowerBound = 13.000000, + .includeLowerBound = true, + .upperBound = 192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 2.718281 }, + .max = { .set = true, .value = 314.159265 }, + .precision = { .set = true, .value = 6 }, + .expectMincoverStrings = { + "0000010011100111000101111011", + "00000100111001110001011111", + "000001001110011100011", + "0000010011100111001", + "000001001110011101", + "00000100111001111", + "0000010011101", + "000001001111", + "00000101", + "0000011", + "00001", + "0001", + "001", + "0100", + "01010", + "0101100", + "0101101000", + "0101101001000000", + "01011010010000010", + "0101101001000001100", + "010110100100000110100", + "0101101001000001101010", + "010110100100000110101100", + "0101101001000001101011010", + "01011010010000011010110110", + }, }, { - .lowerBound = 13.000000, - .includeLowerBound = true, - .upperBound = 192.000000, - .includeUpperBound = true, - .sparsity = 1, - .min = OPT_DOUBLE_C(2.718282), - .max = OPT_DOUBLE_C(314.159265), - .precision = OPT_U32_C(7), - .expectMincoverString = "000001100010000011011101100111\n" \ - "000001100010000011011101101\n" \ - "00000110001000001101110111\n" \ - "00000110001000001101111\n" \ - "0000011000100000111\n" \ - "0000011000100001\n" \ - "000001100010001\n" \ - "00000110001001\n" \ - "0000011000101\n" \ - "000001100011\n" \ - "0000011001\n" \ - "000001101\n" \ - "00000111\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "010\n" \ - "0110\n" \ - "011100000\n" \ - "0111000010\n" \ - "011100001100\n" \ - "011100001101000\n" \ - "01110000110100100000\n" \ - "011100001101001000010\n" \ - "011100001101001000011000\n" \ - "0111000011010010000110010000\n" \ - "01110000110100100001100100010\n" \ - "011100001101001000011001000110\n" \ - "01110000110100100001100100011100\n" + .lowerBound = 13.000000, + .includeLowerBound = true, + .upperBound = 192.000000, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 2.718282 }, + .max = { .set = true, .value = 314.159265 }, + .precision = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "000001100010000011011101100111", + "000001100010000011011101101", + "00000110001000001101110111", + "00000110001000001101111", + "0000011000100000111", + "0000011000100001", + "000001100010001", + "00000110001001", + "0000011000101", + "000001100011", + "0000011001", + "000001101", + "00000111", + "00001", + "0001", + "001", + "010", + "0110", + "011100000", + "0111000010", + "011100001100", + "011100001101000", + "01110000110100100000", + "011100001101001000010", + "011100001101001000011000", + "0111000011010010000110010000", + "01110000110100100001100100010", + "011100001101001000011001000110", + "01110000110100100001100100011100", + }, }, diff --git a/test/data/range-min-cover/mincover_int32.cstruct b/test/data/range-min-cover/mincover_int32.cstruct index 108bb8d44..a8ab2ad46 100644 --- a/test/data/range-min-cover/mincover_int32.cstruct +++ b/test/data/range-min-cover/mincover_int32.cstruct @@ -1,4013 +1,4612 @@ -// This is a copy of test vectors from the mongodb/mongo repository. -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(-1), - .sparsity = 1, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(-1), - .sparsity = 2, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(-1), - .sparsity = 3, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(-1), - .sparsity = 4, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 1, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 2, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 3, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 4, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 3, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000100110001001011000011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(-1), - .sparsity = 1, - .expectMincoverString = "1001100010010110000111\n" \ - "1001100010010110001\n" \ - "100110001001011001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(-1), - .sparsity = 2, - .expectMincoverString = "1001100010010110000111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "100110001001011001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(-1), - .sparsity = 3, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "100110001001011000100\n" \ - "100110001001011000101\n" \ - "100110001001011000110\n" \ - "100110001001011000111\n" \ - "100110001001011001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(-1), - .sparsity = 4, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "10011000100101100100\n" \ - "10011000100101100101\n" \ - "10011000100101100110\n" \ - "10011000100101100111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 1, - .expectMincoverString = "1001100010010110000111\n" \ - "1001100010010110001\n" \ - "100110001001011001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 2, - .expectMincoverString = "1001100010010110000111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "100110001001011001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 3, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "100110001001011000100\n" \ - "100110001001011000101\n" \ - "100110001001011000110\n" \ - "100110001001011000111\n" \ - "100110001001011001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 4, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "10011000100101100100\n" \ - "10011000100101100101\n" \ - "10011000100101100110\n" \ - "10011000100101100111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "1001100010010110000111\n" \ - "1001100010010110001\n" \ - "100110001001011001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "1001100010010110000111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "100110001001011001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 3, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "100110001001011000100\n" \ - "100110001001011000101\n" \ - "100110001001011000110\n" \ - "100110001001011000111\n" \ - "100110001001011001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "10011000100101100100\n" \ - "10011000100101100101\n" \ - "10011000100101100110\n" \ - "10011000100101100111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "1001100010010110000111\n" \ - "1001100010010110001\n" \ - "100110001001011001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "1001100010010110000111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "100110001001011001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "100110001001011000100\n" \ - "100110001001011000101\n" \ - "100110001001011000110\n" \ - "100110001001011000111\n" \ - "100110001001011001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "10011000100101100100\n" \ - "10011000100101100101\n" \ - "10011000100101100110\n" \ - "10011000100101100111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "00000001001100010010110000111\n" \ - "00000001001100010010110001\n" \ - "0000000100110001001011001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 2, - .expectMincoverString = "000000010011000100101100001110\n" \ - "000000010011000100101100001111\n" \ - "00000001001100010010110001\n" \ - "00000001001100010010110010\n" \ - "00000001001100010010110011\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 3, - .expectMincoverString = "000000010011000100101100001110\n" \ - "000000010011000100101100001111\n" \ - "000000010011000100101100010\n" \ - "000000010011000100101100011\n" \ - "000000010011000100101100100\n" \ - "000000010011000100101100101\n" \ - "000000010011000100101100110\n" \ - "000000010011000100101100111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 1, - .expectMincoverString = "1001100010010110000111\n" \ - "1001100010010110001\n" \ - "100110001001011001\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 2, - .expectMincoverString = "1001100010010110000111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "100110001001011001\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 3, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "100110001001011000100\n" \ - "100110001001011000101\n" \ - "100110001001011000110\n" \ - "100110001001011000111\n" \ - "100110001001011001\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 4, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "10011000100101100100\n" \ - "10011000100101100101\n" \ - "10011000100101100110\n" \ - "10011000100101100111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "1001100010010110000111\n" \ - "1001100010010110001\n" \ - "100110001001011001\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "1001100010010110000111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "100110001001011001\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 3, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "100110001001011000100\n" \ - "100110001001011000101\n" \ - "100110001001011000110\n" \ - "100110001001011000111\n" \ - "100110001001011001\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "10011000100101100100\n" \ - "10011000100101100101\n" \ - "10011000100101100110\n" \ - "10011000100101100111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "1001100010010110000111\n" \ - "1001100010010110001\n" \ - "100110001001011001\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "1001100010010110000111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "100110001001011001\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "100110001001011000100\n" \ - "100110001001011000101\n" \ - "100110001001011000110\n" \ - "100110001001011000111\n" \ - "100110001001011001\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "10011000100101100100\n" \ - "10011000100101100101\n" \ - "10011000100101100110\n" \ - "10011000100101100111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "00000001001100010010110000111\n" \ - "00000001001100010010110001\n" \ - "0000000100110001001011001\n" \ - "0000000100110001001011010000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "1001100010010110000111\n" \ - "1001100010010110001\n" \ - "100110001001011001\n" \ - "100110001001011010000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "1001100010010110000111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "100110001001011001\n" \ - "1001100010010110100000\n" \ - "1001100010010110100001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 3, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "100110001001011000100\n" \ - "100110001001011000101\n" \ - "100110001001011000110\n" \ - "100110001001011000111\n" \ - "100110001001011001\n" \ - "100110001001011010000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "10011000100101100100\n" \ - "10011000100101100101\n" \ - "10011000100101100110\n" \ - "10011000100101100111\n" \ - "100110001001011010000000\n" \ - "100110001001011010000001\n" \ - "100110001001011010000010\n" \ - "100110001001011010000011\n" \ - "100110001001011010000100\n" \ - "100110001001011010000101\n" \ - "100110001001011010000110\n" \ - "100110001001011010000111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "1001100010010110000111\n" \ - "1001100010010110001\n" \ - "100110001001011001\n" \ - "100110001001011010000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "1001100010010110000111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "100110001001011001\n" \ - "1001100010010110100000\n" \ - "1001100010010110100001\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "100110001001011000100\n" \ - "100110001001011000101\n" \ - "100110001001011000110\n" \ - "100110001001011000111\n" \ - "100110001001011001\n" \ - "100110001001011010000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "10011000100101100100\n" \ - "10011000100101100101\n" \ - "10011000100101100110\n" \ - "10011000100101100111\n" \ - "100110001001011010000000\n" \ - "100110001001011010000001\n" \ - "100110001001011010000010\n" \ - "100110001001011010000011\n" \ - "100110001001011010000100\n" \ - "100110001001011010000101\n" \ - "100110001001011010000110\n" \ - "100110001001011010000111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "00000001001100010010110000111\n" \ - "00000001001100010010110001\n" \ - "0000000100110001001011001\n" \ - "0000000100110001001011010000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 2, - .expectMincoverString = "000000010011000100101100001110\n" \ - "000000010011000100101100001111\n" \ - "00000001001100010010110001\n" \ - "00000001001100010010110010\n" \ - "00000001001100010010110011\n" \ - "0000000100110001001011010000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 3, - .expectMincoverString = "000000010011000100101100001110\n" \ - "000000010011000100101100001111\n" \ - "000000010011000100101100010\n" \ - "000000010011000100101100011\n" \ - "000000010011000100101100100\n" \ - "000000010011000100101100101\n" \ - "000000010011000100101100110\n" \ - "000000010011000100101100111\n" \ - "000000010011000100101101000000\n" \ - "000000010011000100101101000001\n" \ - "000000010011000100101101000010\n" \ - "000000010011000100101101000011\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "1001100010010110000111\n" \ - "1001100010010110001\n" \ - "100110001001011001\n" \ - "1001100010010110100\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "1001100010010110000111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "100110001001011001\n" \ - "10011000100101101000\n" \ - "10011000100101101001\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "100110001001011000100\n" \ - "100110001001011000101\n" \ - "100110001001011000110\n" \ - "100110001001011000111\n" \ - "100110001001011001\n" \ - "100110001001011010000\n" \ - "100110001001011010001\n" \ - "100110001001011010010\n" \ - "100110001001011010011\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "100110001001011000011100\n" \ - "100110001001011000011101\n" \ - "100110001001011000011110\n" \ - "100110001001011000011111\n" \ - "10011000100101100010\n" \ - "10011000100101100011\n" \ - "10011000100101100100\n" \ - "10011000100101100101\n" \ - "10011000100101100110\n" \ - "10011000100101100111\n" \ - "10011000100101101000\n" \ - "10011000100101101001\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "00000001001100010010110000111\n" \ - "00000001001100010010110001\n" \ - "0000000100110001001011001\n" \ - "00000001001100010010110100\n" \ - "0000000100110001001011010100000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "00000001001100010010110000111\n" \ - "00000001001100010010110001\n" \ - "0000000100110001001011001\n" \ - "000000010011000100101101\n" \ - "00000001001100010010111\n" \ - "00000001001100010011\n" \ - "000000010011000101\n" \ - "00000001001100011\n" \ - "000000010011001\n" \ - "00000001001101\n" \ - "0000000100111\n" \ - "0000000101\n" \ - "000000011\n" \ - "0000001\n" \ - "000001\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "01\n" \ - "10\n" \ - "110\n" \ - "11100000\n" \ - "11100001000\n" \ - "111000010010\n" \ - "1110000100110000\n" \ - "1110000100110001000\n" \ - "111000010011000100100\n" \ - "1110000100110001001010\n" \ - "111000010011000100101100\n" \ - "1110000100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(-1), - .sparsity = 1, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(-1), - .sparsity = 2, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(-1), - .sparsity = 3, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(-1), - .sparsity = 4, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 1, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 2, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 3, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 4, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 3, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000100110001001011001111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(0), - .sparsity = 1, - .expectMincoverString = "0\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "0000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "0000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "0000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 1, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 2, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 3, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 4, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 3, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000100110001001011001111111\n" \ - "0000000100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(0), - .sparsity = 1, - .expectMincoverString = "root\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(0), - .sparsity = 2, - .expectMincoverString = "root\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(0), - .sparsity = 3, - .expectMincoverString = "root\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(0), - .sparsity = 4, - .expectMincoverString = "root\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "0000\n" \ - "0001\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 3, - .expectMincoverString = "000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "0000\n" \ - "0001\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "00000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "000000\n" \ - "000001\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "000000\n" \ - "000001\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 2, - .expectMincoverString = "000000000000000000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "100110001001011001111111\n" \ - "1001100010010110100000\n" \ - "1001100010010110100001\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 3, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000000\n" \ - "100110001001011010000001\n" \ - "100110001001011010000010\n" \ - "100110001001011010000011\n" \ - "100110001001011010000100\n" \ - "100110001001011010000101\n" \ - "100110001001011010000110\n" \ - "100110001001011010000111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "100110001001011001111111\n" \ - "1001100010010110100000\n" \ - "1001100010010110100001\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000000\n" \ - "100110001001011010000001\n" \ - "100110001001011010000010\n" \ - "100110001001011010000011\n" \ - "100110001001011010000100\n" \ - "100110001001011010000101\n" \ - "100110001001011010000110\n" \ - "100110001001011010000111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000100110001001011001111111\n" \ - "0000000100110001001011010000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "0\n" \ - "1000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "00\n" \ - "01\n" \ - "1000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "0000\n" \ - "0001\n" \ - "0010\n" \ - "0011\n" \ - "0100\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "1000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "000\n" \ - "001000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "0000\n" \ - "0001\n" \ - "001000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "000\n" \ - "001000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000000\n" \ - "0000000000000000000000000001000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "100110001001011001111111\n" \ - "1001100010010110100\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "100110001001011001111111\n" \ - "10011000100101101000\n" \ - "10011000100101101001\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011001111111\n" \ - "100110001001011010000\n" \ - "100110001001011010001\n" \ - "100110001001011010010\n" \ - "100110001001011010011\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "100110001001011001111111\n" \ - "10011000100101101000\n" \ - "10011000100101101001\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000100110001001011001111111\n" \ - "00000001001100010010110100\n" \ - "0000000100110001001011010100000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "0\n" \ - "10000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "00\n" \ - "01\n" \ - "100000\n" \ - "100001\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "000\n" \ - "001\n" \ - "010\n" \ - "011\n" \ - "100000\n" \ - "100001\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "00000000000000000000000000\n" \ - "000000000000000000000000010000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 2, - .expectMincoverString = "00000000000000000000000000\n" \ - "000000000000000000000000010000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000\n" \ - "000000000000000000000000001\n" \ - "000000000000000000000000010000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000100110001001011001111111\n" \ - "000000010011000100101101\n" \ - "00000001001100010010111\n" \ - "00000001001100010011\n" \ - "000000010011000101\n" \ - "00000001001100011\n" \ - "000000010011001\n" \ - "00000001001101\n" \ - "0000000100111\n" \ - "0000000101\n" \ - "000000011\n" \ - "0000001\n" \ - "000001\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "01\n" \ - "10\n" \ - "110\n" \ - "11100000\n" \ - "11100001000\n" \ - "111000010010\n" \ - "1110000100110000\n" \ - "1110000100110001000\n" \ - "111000010011000100100\n" \ - "1110000100110001001010\n" \ - "111000010011000100101100\n" \ - "1110000100110001001011010000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0\n" \ - "10\n" \ - "110\n" \ - "111000000000000000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 2, - .expectMincoverString = "00\n" \ - "01\n" \ - "10\n" \ - "1100\n" \ - "1101\n" \ - "111000000000000000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 3, - .expectMincoverString = "000\n" \ - "001\n" \ - "010\n" \ - "011\n" \ - "100\n" \ - "101\n" \ - "110\n" \ - "111000000000000000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 1, - .expectMincoverString = "100110001001011010000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 2, - .expectMincoverString = "100110001001011010000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 3, - .expectMincoverString = "100110001001011010000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(0), - .sparsity = 4, - .expectMincoverString = "100110001001011010000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "100110001001011010000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "100110001001011010000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 3, - .expectMincoverString = "100110001001011010000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "100110001001011010000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "100110001001011010000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "100110001001011010000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011010000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "100110001001011010000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000100110001001011010000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(0), - .sparsity = 1, - .expectMincoverString = "1\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "0001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "0001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "0001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "000001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "000001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "000001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000000001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(7), - .sparsity = 3, - .expectMincoverString = "000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "100110001001011010000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "1001100010010110100000\n" \ - "1001100010010110100001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 3, - .expectMincoverString = "100110001001011010000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "100110001001011010000000\n" \ - "100110001001011010000001\n" \ - "100110001001011010000010\n" \ - "100110001001011010000011\n" \ - "100110001001011010000100\n" \ - "100110001001011010000101\n" \ - "100110001001011010000110\n" \ - "100110001001011010000111\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "100110001001011010000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "1001100010010110100000\n" \ - "1001100010010110100001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011010000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "100110001001011010000000\n" \ - "100110001001011010000001\n" \ - "100110001001011010000010\n" \ - "100110001001011010000011\n" \ - "100110001001011010000100\n" \ - "100110001001011010000101\n" \ - "100110001001011010000110\n" \ - "100110001001011010000111\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000100110001001011010000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 2, - .expectMincoverString = "0000000100110001001011010000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 3, - .expectMincoverString = "000000010011000100101101000000\n" \ - "000000010011000100101101000001\n" \ - "000000010011000100101101000010\n" \ - "000000010011000100101101000011\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 4, - .expectMincoverString = "0000000100110001001011010000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "0001\n" \ - "001\n" \ - "01\n" \ - "1000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "0001\n" \ - "0010\n" \ - "0011\n" \ - "01\n" \ - "1000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "0001\n" \ - "0010\n" \ - "0011\n" \ - "0100\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "1000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "000001\n" \ - "00001\n" \ - "0001\n" \ - "001000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "000001\n" \ - "000010\n" \ - "000011\n" \ - "0001\n" \ - "001000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "000001\n" \ - "000010\n" \ - "000011\n" \ - "000100\n" \ - "000101\n" \ - "000110\n" \ - "000111\n" \ - "001000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000000001\n" \ - "000000000000000000000000000001\n" \ - "00000000000000000000000000001\n" \ - "0000000000000000000000000001000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "root\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "root\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(7), - .sparsity = 3, - .expectMincoverString = "root\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "root\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "0000\n" \ - "0001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "0000\n" \ - "0001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(1879048192), - .sparsity = 2, - .expectMincoverString = "0000000000000000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(1879048192), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000\n" \ - "000000000000000000000000000001\n" \ - "000000000000000000000000000010\n" \ - "000000000000000000000000000011\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(1879048192), - .sparsity = 4, - .expectMincoverString = "0000000000000000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "1001100010010110100\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "10011000100101101000\n" \ - "10011000100101101001\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011010000\n" \ - "100110001001011010001\n" \ - "100110001001011010010\n" \ - "100110001001011010011\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "10011000100101101000\n" \ - "10011000100101101001\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "00000001001100010010110100\n" \ - "0000000100110001001011010100000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "000001\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "01\n" \ - "10000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "000001\n" \ - "000010\n" \ - "000011\n" \ - "0001\n" \ - "0010\n" \ - "0011\n" \ - "01\n" \ - "100000\n" \ - "100001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "000001\n" \ - "000010\n" \ - "000011\n" \ - "000100\n" \ - "000101\n" \ - "000110\n" \ - "000111\n" \ - "001\n" \ - "010\n" \ - "011\n" \ - "100000\n" \ - "100001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000000001\n" \ - "000000000000000000000000000001\n" \ - "00000000000000000000000000001\n" \ - "0000000000000000000000000001\n" \ - "000000000000000000000000001\n" \ - "000000000000000000000000010000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "0\n" \ - "100000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "00\n" \ - "01\n" \ - "100000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "000\n" \ - "001\n" \ - "010\n" \ - "011\n" \ - "100000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "00000000000000000000000000\n" \ - "0000000000000000000000000100000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "000000010011000100101101\n" \ - "00000001001100010010111\n" \ - "00000001001100010011\n" \ - "000000010011000101\n" \ - "00000001001100011\n" \ - "000000010011001\n" \ - "00000001001101\n" \ - "0000000100111\n" \ - "0000000101\n" \ - "000000011\n" \ - "0000001\n" \ - "000001\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "01\n" \ - "10\n" \ - "110\n" \ - "11100000\n" \ - "11100001000\n" \ - "111000010010\n" \ - "1110000100110000\n" \ - "1110000100110001000\n" \ - "111000010011000100100\n" \ - "1110000100110001001010\n" \ - "111000010011000100101100\n" \ - "1110000100110001001011010000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000000001\n" \ - "000000000000000000000000000001\n" \ - "00000000000000000000000000001\n" \ - "0000000000000000000000000001\n" \ - "000000000000000000000000001\n" \ - "00000000000000000000000001\n" \ - "0000000000000000000000001\n" \ - "000000000000000000000001\n" \ - "00000000000000000000001\n" \ - "0000000000000000000001\n" \ - "000000000000000000001\n" \ - "00000000000000000001\n" \ - "0000000000000000001\n" \ - "000000000000000001\n" \ - "00000000000000001\n" \ - "0000000000000001\n" \ - "000000000000001\n" \ - "00000000000001\n" \ - "0000000000001\n" \ - "000000000001\n" \ - "00000000001\n" \ - "0000000001\n" \ - "000000001\n" \ - "00000001\n" \ - "0000001\n" \ - "000001\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "01\n" \ - "10\n" \ - "110\n" \ - "111000000000000000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0\n" \ - "10\n" \ - "110\n" \ - "1110000000000000000000000000000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "100110001001011010000111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "100110001001011010000111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 3, - .expectMincoverString = "100110001001011010000111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "100110001001011010000111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "100110001001011010000111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "100110001001011010000111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011010000111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "100110001001011010000111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000100110001001011010000111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "1000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 2, - .expectMincoverString = "1000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(7), - .sparsity = 4, - .expectMincoverString = "1000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "001000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "001000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "001000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000001000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(7), - .sparsity = 1, - .expectMincoverString = "111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(7), - .sparsity = 3, - .expectMincoverString = "111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "000111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "000111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "000111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000000111\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(7), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "00000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 7, - .includeUpperBound = true, - .min = OPT_I32_C(7), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000000000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "100110001001011010000111\n" \ - "100110001001011010001\n" \ - "10011000100101101001\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "100110001001011010000111\n" \ - "1001100010010110100010\n" \ - "1001100010010110100011\n" \ - "10011000100101101001\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011010000111\n" \ - "100110001001011010001\n" \ - "100110001001011010010\n" \ - "100110001001011010011\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "100110001001011010000111\n" \ - "100110001001011010001000\n" \ - "100110001001011010001001\n" \ - "100110001001011010001010\n" \ - "100110001001011010001011\n" \ - "100110001001011010001100\n" \ - "100110001001011010001101\n" \ - "100110001001011010001110\n" \ - "100110001001011010001111\n" \ - "10011000100101101001\n" \ - "100110001001011010100000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000100110001001011010000111\n" \ - "0000000100110001001011010001\n" \ - "000000010011000100101101001\n" \ - "0000000100110001001011010100000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "001\n" \ - "01\n" \ - "10000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "0010\n" \ - "0011\n" \ - "01\n" \ - "100000\n" \ - "100001\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "001\n" \ - "010\n" \ - "011\n" \ - "100000\n" \ - "100001\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000001\n" \ - "000000000000000000000000001\n" \ - "000000000000000000000000010000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 2, - .expectMincoverString = "0000000000000000000000000001\n" \ - "0000000000000000000000000010\n" \ - "0000000000000000000000000011\n" \ - "000000000000000000000000010000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000100\n" \ - "000000000000000000000000000101\n" \ - "000000000000000000000000000110\n" \ - "000000000000000000000000000111\n" \ - "000000000000000000000000001\n" \ - "000000000000000000000000010000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "000111\n" \ - "001\n" \ - "01\n" \ - "100000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "000111\n" \ - "0010\n" \ - "0011\n" \ - "01\n" \ - "100000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "000111\n" \ - "001\n" \ - "010\n" \ - "011\n" \ - "100000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000000111\n" \ - "0000000000000000000000000001\n" \ - "000000000000000000000000001\n" \ - "0000000000000000000000000100000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(7), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "0\n" \ - "10\n" \ - "1100\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(7), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "00\n" \ - "01\n" \ - "10\n" \ - "1100\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(7), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "0000\n" \ - "0001\n" \ - "0010\n" \ - "0011\n" \ - "0100\n" \ - "0101\n" \ - "0110\n" \ - "0111\n" \ - "1000\n" \ - "1001\n" \ - "1010\n" \ - "1011\n" \ - "1100\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(7), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000\n" \ - "0000000000000000000000000010\n" \ - "000000000000000000000000001100\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(7), - .max = OPT_I32_C(1879048192), - .sparsity = 2, - .expectMincoverString = "0000000000000000000000000000\n" \ - "0000000000000000000000000001\n" \ - "0000000000000000000000000010\n" \ - "000000000000000000000000001100\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(7), - .max = OPT_I32_C(1879048192), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000\n" \ - "000000000000000000000000001000\n" \ - "000000000000000000000000001001\n" \ - "000000000000000000000000001010\n" \ - "000000000000000000000000001011\n" \ - "000000000000000000000000001100\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000100110001001011010000111\n" \ - "0000000100110001001011010001\n" \ - "000000010011000100101101001\n" \ - "00000001001100010010110101\n" \ - "0000000100110001001011011\n" \ - "00000001001100010010111\n" \ - "00000001001100010011\n" \ - "000000010011000101\n" \ - "00000001001100011\n" \ - "000000010011001\n" \ - "00000001001101\n" \ - "0000000100111\n" \ - "0000000101\n" \ - "000000011\n" \ - "0000001\n" \ - "000001\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "01\n" \ - "10\n" \ - "110\n" \ - "11100000\n" \ - "11100001000\n" \ - "111000010010\n" \ - "1110000100110000\n" \ - "1110000100110001000\n" \ - "111000010011000100100\n" \ - "1110000100110001001010\n" \ - "111000010011000100101100\n" \ - "1110000100110001001011010000000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000001\n" \ - "000000000000000000000000001\n" \ - "00000000000000000000000001\n" \ - "0000000000000000000000001\n" \ - "000000000000000000000001\n" \ - "00000000000000000000001\n" \ - "0000000000000000000001\n" \ - "000000000000000000001\n" \ - "00000000000000000001\n" \ - "0000000000000000001\n" \ - "000000000000000001\n" \ - "00000000000000001\n" \ - "0000000000000001\n" \ - "000000000000001\n" \ - "00000000000001\n" \ - "0000000000001\n" \ - "000000000001\n" \ - "00000000001\n" \ - "0000000001\n" \ - "000000001\n" \ - "00000001\n" \ - "0000001\n" \ - "000001\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "01\n" \ - "10\n" \ - "110\n" \ - "111000000000000000000000000000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 2, - .expectMincoverString = "0000000000000000000000000001\n" \ - "0000000000000000000000000010\n" \ - "0000000000000000000000000011\n" \ - "00000000000000000000000001\n" \ - "00000000000000000000000010\n" \ - "00000000000000000000000011\n" \ - "000000000000000000000001\n" \ - "000000000000000000000010\n" \ - "000000000000000000000011\n" \ - "0000000000000000000001\n" \ - "0000000000000000000010\n" \ - "0000000000000000000011\n" \ - "00000000000000000001\n" \ - "00000000000000000010\n" \ - "00000000000000000011\n" \ - "000000000000000001\n" \ - "000000000000000010\n" \ - "000000000000000011\n" \ - "0000000000000001\n" \ - "0000000000000010\n" \ - "0000000000000011\n" \ - "00000000000001\n" \ - "00000000000010\n" \ - "00000000000011\n" \ - "000000000001\n" \ - "000000000010\n" \ - "000000000011\n" \ - "0000000001\n" \ - "0000000010\n" \ - "0000000011\n" \ - "00000001\n" \ - "00000010\n" \ - "00000011\n" \ - "000001\n" \ - "000010\n" \ - "000011\n" \ - "0001\n" \ - "0010\n" \ - "0011\n" \ - "01\n" \ - "10\n" \ - "1100\n" \ - "1101\n" \ - "111000000000000000000000000000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000000111\n" \ - "0000000000000000000000000001\n" \ - "000000000000000000000000001\n" \ - "00000000000000000000000001\n" \ - "0000000000000000000000001\n" \ - "000000000000000000000001\n" \ - "00000000000000000000001\n" \ - "0000000000000000000001\n" \ - "000000000000000000001\n" \ - "00000000000000000001\n" \ - "0000000000000000001\n" \ - "000000000000000001\n" \ - "00000000000000001\n" \ - "0000000000000001\n" \ - "000000000000001\n" \ - "00000000000001\n" \ - "0000000000001\n" \ - "000000000001\n" \ - "00000000001\n" \ - "0000000001\n" \ - "000000001\n" \ - "00000001\n" \ - "0000001\n" \ - "000001\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "01\n" \ - "10\n" \ - "110\n" \ - "1110000000000000000000000000000\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(7), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0\n" \ - "10\n" \ - "1100\n" \ - "11010\n" \ - "110110\n" \ - "1101110\n" \ - "11011110\n" \ - "110111110\n" \ - "1101111110\n" \ - "11011111110\n" \ - "110111111110\n" \ - "1101111111110\n" \ - "11011111111110\n" \ - "110111111111110\n" \ - "1101111111111110\n" \ - "11011111111111110\n" \ - "110111111111111110\n" \ - "1101111111111111110\n" \ - "11011111111111111110\n" \ - "110111111111111111110\n" \ - "1101111111111111111110\n" \ - "11011111111111111111110\n" \ - "110111111111111111111110\n" \ - "1101111111111111111111110\n" \ - "11011111111111111111111110\n" \ - "110111111111111111111111110\n" \ - "1101111111111111111111111110\n" \ - "110111111111111111111111111100\n" -}, -{ - .lowerBound = 7, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(7), - .max = OPT_I32_C(1879048192), - .sparsity = 2, - .expectMincoverString = "00\n" \ - "01\n" \ - "10\n" \ - "1100\n" \ - "110100\n" \ - "110101\n" \ - "110110\n" \ - "11011100\n" \ - "11011101\n" \ - "11011110\n" \ - "1101111100\n" \ - "1101111101\n" \ - "1101111110\n" \ - "110111111100\n" \ - "110111111101\n" \ - "110111111110\n" \ - "11011111111100\n" \ - "11011111111101\n" \ - "11011111111110\n" \ - "1101111111111100\n" \ - "1101111111111101\n" \ - "1101111111111110\n" \ - "110111111111111100\n" \ - "110111111111111101\n" \ - "110111111111111110\n" \ - "11011111111111111100\n" \ - "11011111111111111101\n" \ - "11011111111111111110\n" \ - "1101111111111111111100\n" \ - "1101111111111111111101\n" \ - "1101111111111111111110\n" \ - "110111111111111111111100\n" \ - "110111111111111111111101\n" \ - "110111111111111111111110\n" \ - "11011111111111111111111100\n" \ - "11011111111111111111111101\n" \ - "11011111111111111111111110\n" \ - "1101111111111111111111111100\n" \ - "1101111111111111111111111101\n" \ - "1101111111111111111111111110\n" \ - "110111111111111111111111111100\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "100110001001011010100000\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "100110001001011010100000\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100110001001011010100000\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(32), - .sparsity = 4, - .expectMincoverString = "100110001001011010100000\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000100110001001011010100000\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "100001\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "100001\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100001\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000100001\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "100000\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 2, - .expectMincoverString = "100000\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(32), - .sparsity = 3, - .expectMincoverString = "100000\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000100000\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(7), - .max = OPT_I32_C(32), - .sparsity = 1, - .expectMincoverString = "11001\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(7), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000011001\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 32, - .includeUpperBound = true, - .min = OPT_I32_C(32), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000000000\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "00000001001100010010110101\n" \ - "0000000100110001001011011\n" \ - "00000001001100010010111\n" \ - "00000001001100010011\n" \ - "000000010011000101\n" \ - "00000001001100011\n" \ - "000000010011001\n" \ - "00000001001101\n" \ - "0000000100111\n" \ - "0000000101\n" \ - "000000011\n" \ - "0000001\n" \ - "000001\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "01\n" \ - "10\n" \ - "110\n" \ - "11100000\n" \ - "11100001000\n" \ - "111000010010\n" \ - "1110000100110000\n" \ - "1110000100110001000\n" \ - "111000010011000100100\n" \ - "1110000100110001001010\n" \ - "111000010011000100101100\n" \ - "1110000100110001001011010000000\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0000000000000000000000000100001\n" \ - "000000000000000000000000010001\n" \ - "00000000000000000000000001001\n" \ - "0000000000000000000000000101\n" \ - "000000000000000000000000011\n" \ - "0000000000000000000000001\n" \ - "000000000000000000000001\n" \ - "00000000000000000000001\n" \ - "0000000000000000000001\n" \ - "000000000000000000001\n" \ - "00000000000000000001\n" \ - "0000000000000000001\n" \ - "000000000000000001\n" \ - "00000000000000001\n" \ - "0000000000000001\n" \ - "000000000000001\n" \ - "00000000000001\n" \ - "0000000000001\n" \ - "000000000001\n" \ - "00000000001\n" \ - "0000000001\n" \ - "000000001\n" \ - "00000001\n" \ - "0000001\n" \ - "000001\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "01\n" \ - "10\n" \ - "110\n" \ - "111000000000000000000000000000\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "00000000000000000000000001\n" \ - "0000000000000000000000001\n" \ - "000000000000000000000001\n" \ - "00000000000000000000001\n" \ - "0000000000000000000001\n" \ - "000000000000000000001\n" \ - "00000000000000000001\n" \ - "0000000000000000001\n" \ - "000000000000000001\n" \ - "00000000000000001\n" \ - "0000000000000001\n" \ - "000000000000001\n" \ - "00000000000001\n" \ - "0000000000001\n" \ - "000000000001\n" \ - "00000000001\n" \ - "0000000001\n" \ - "000000001\n" \ - "00000001\n" \ - "0000001\n" \ - "000001\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "01\n" \ - "10\n" \ - "110\n" \ - "1110000000000000000000000000000\n" -}, -{ - .lowerBound = 32, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(32), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "0\n" \ - "10\n" \ - "1100\n" \ - "11010\n" \ - "110110\n" \ - "1101110\n" \ - "11011110\n" \ - "110111110\n" \ - "1101111110\n" \ - "11011111110\n" \ - "110111111110\n" \ - "1101111111110\n" \ - "11011111111110\n" \ - "110111111111110\n" \ - "1101111111111110\n" \ - "11011111111111110\n" \ - "110111111111111110\n" \ - "1101111111111111110\n" \ - "11011111111111111110\n" \ - "110111111111111111110\n" \ - "1101111111111111111110\n" \ - "11011111111111111111110\n" \ - "110111111111111111111110\n" \ - "1101111111111111111111110\n" \ - "11011111111111111111111110\n" \ - "1101111111111111111111111100000\n" -}, -{ - .lowerBound = 1879048192, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(-10000000), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "1110000100110001001011010000000\n" -}, -{ - .lowerBound = 1879048192, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(-1), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "1110000000000000000000000000001\n" -}, -{ - .lowerBound = 1879048192, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(0), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "1110000000000000000000000000000\n" -}, -{ - .lowerBound = 1879048192, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(7), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "1101111111111111111111111111001\n" -}, -{ - .lowerBound = 1879048192, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I32_C(32), - .max = OPT_I32_C(1879048192), - .sparsity = 1, - .expectMincoverString = "1101111111111111111111111100000\n" +// This code is GENERATED! Do not edit! +// clang-format off +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000100110001001011000011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "1001100010010110000111", + "1001100010010110001", + "100110001001011001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "1001100010010110000111", + "10011000100101100010", + "10011000100101100011", + "100110001001011001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "100110001001011000100", + "100110001001011000101", + "100110001001011000110", + "100110001001011000111", + "100110001001011001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "10011000100101100010", + "10011000100101100011", + "10011000100101100100", + "10011000100101100101", + "10011000100101100110", + "10011000100101100111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "1001100010010110000111", + "1001100010010110001", + "100110001001011001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "1001100010010110000111", + "10011000100101100010", + "10011000100101100011", + "100110001001011001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "100110001001011000100", + "100110001001011000101", + "100110001001011000110", + "100110001001011000111", + "100110001001011001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "10011000100101100010", + "10011000100101100011", + "10011000100101100100", + "10011000100101100101", + "10011000100101100110", + "10011000100101100111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "1001100010010110000111", + "1001100010010110001", + "100110001001011001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "1001100010010110000111", + "10011000100101100010", + "10011000100101100011", + "100110001001011001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "100110001001011000100", + "100110001001011000101", + "100110001001011000110", + "100110001001011000111", + "100110001001011001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "10011000100101100010", + "10011000100101100011", + "10011000100101100100", + "10011000100101100101", + "10011000100101100110", + "10011000100101100111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "1001100010010110000111", + "1001100010010110001", + "100110001001011001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "1001100010010110000111", + "10011000100101100010", + "10011000100101100011", + "100110001001011001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "100110001001011000100", + "100110001001011000101", + "100110001001011000110", + "100110001001011000111", + "100110001001011001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "10011000100101100010", + "10011000100101100011", + "10011000100101100100", + "10011000100101100101", + "10011000100101100110", + "10011000100101100111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "00000001001100010010110000111", + "00000001001100010010110001", + "0000000100110001001011001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000000010011000100101100001110", + "000000010011000100101100001111", + "00000001001100010010110001", + "00000001001100010010110010", + "00000001001100010010110011", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000000010011000100101100001110", + "000000010011000100101100001111", + "000000010011000100101100010", + "000000010011000100101100011", + "000000010011000100101100100", + "000000010011000100101100101", + "000000010011000100101100110", + "000000010011000100101100111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "1001100010010110000111", + "1001100010010110001", + "100110001001011001", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "1001100010010110000111", + "10011000100101100010", + "10011000100101100011", + "100110001001011001", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "100110001001011000100", + "100110001001011000101", + "100110001001011000110", + "100110001001011000111", + "100110001001011001", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "10011000100101100010", + "10011000100101100011", + "10011000100101100100", + "10011000100101100101", + "10011000100101100110", + "10011000100101100111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "1001100010010110000111", + "1001100010010110001", + "100110001001011001", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "1001100010010110000111", + "10011000100101100010", + "10011000100101100011", + "100110001001011001", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "100110001001011000100", + "100110001001011000101", + "100110001001011000110", + "100110001001011000111", + "100110001001011001", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "10011000100101100010", + "10011000100101100011", + "10011000100101100100", + "10011000100101100101", + "10011000100101100110", + "10011000100101100111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "1001100010010110000111", + "1001100010010110001", + "100110001001011001", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "1001100010010110000111", + "10011000100101100010", + "10011000100101100011", + "100110001001011001", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "100110001001011000100", + "100110001001011000101", + "100110001001011000110", + "100110001001011000111", + "100110001001011001", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "10011000100101100010", + "10011000100101100011", + "10011000100101100100", + "10011000100101100101", + "10011000100101100110", + "10011000100101100111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "00000001001100010010110000111", + "00000001001100010010110001", + "0000000100110001001011001", + "0000000100110001001011010000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "1001100010010110000111", + "1001100010010110001", + "100110001001011001", + "100110001001011010000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "1001100010010110000111", + "10011000100101100010", + "10011000100101100011", + "100110001001011001", + "1001100010010110100000", + "1001100010010110100001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "100110001001011000100", + "100110001001011000101", + "100110001001011000110", + "100110001001011000111", + "100110001001011001", + "100110001001011010000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "10011000100101100010", + "10011000100101100011", + "10011000100101100100", + "10011000100101100101", + "10011000100101100110", + "10011000100101100111", + "100110001001011010000000", + "100110001001011010000001", + "100110001001011010000010", + "100110001001011010000011", + "100110001001011010000100", + "100110001001011010000101", + "100110001001011010000110", + "100110001001011010000111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "1001100010010110000111", + "1001100010010110001", + "100110001001011001", + "100110001001011010000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "1001100010010110000111", + "10011000100101100010", + "10011000100101100011", + "100110001001011001", + "1001100010010110100000", + "1001100010010110100001", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "100110001001011000100", + "100110001001011000101", + "100110001001011000110", + "100110001001011000111", + "100110001001011001", + "100110001001011010000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "10011000100101100010", + "10011000100101100011", + "10011000100101100100", + "10011000100101100101", + "10011000100101100110", + "10011000100101100111", + "100110001001011010000000", + "100110001001011010000001", + "100110001001011010000010", + "100110001001011010000011", + "100110001001011010000100", + "100110001001011010000101", + "100110001001011010000110", + "100110001001011010000111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "00000001001100010010110000111", + "00000001001100010010110001", + "0000000100110001001011001", + "0000000100110001001011010000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000000010011000100101100001110", + "000000010011000100101100001111", + "00000001001100010010110001", + "00000001001100010010110010", + "00000001001100010010110011", + "0000000100110001001011010000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000000010011000100101100001110", + "000000010011000100101100001111", + "000000010011000100101100010", + "000000010011000100101100011", + "000000010011000100101100100", + "000000010011000100101100101", + "000000010011000100101100110", + "000000010011000100101100111", + "000000010011000100101101000000", + "000000010011000100101101000001", + "000000010011000100101101000010", + "000000010011000100101101000011", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "1001100010010110000111", + "1001100010010110001", + "100110001001011001", + "1001100010010110100", + "100110001001011010100000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "1001100010010110000111", + "10011000100101100010", + "10011000100101100011", + "100110001001011001", + "10011000100101101000", + "10011000100101101001", + "100110001001011010100000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "100110001001011000100", + "100110001001011000101", + "100110001001011000110", + "100110001001011000111", + "100110001001011001", + "100110001001011010000", + "100110001001011010001", + "100110001001011010010", + "100110001001011010011", + "100110001001011010100000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011000011100", + "100110001001011000011101", + "100110001001011000011110", + "100110001001011000011111", + "10011000100101100010", + "10011000100101100011", + "10011000100101100100", + "10011000100101100101", + "10011000100101100110", + "10011000100101100111", + "10011000100101101000", + "10011000100101101001", + "100110001001011010100000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "00000001001100010010110000111", + "00000001001100010010110001", + "0000000100110001001011001", + "00000001001100010010110100", + "0000000100110001001011010100000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "00000001001100010010110000111", + "00000001001100010010110001", + "0000000100110001001011001", + "000000010011000100101101", + "00000001001100010010111", + "00000001001100010011", + "000000010011000101", + "00000001001100011", + "000000010011001", + "00000001001101", + "0000000100111", + "0000000101", + "000000011", + "0000001", + "000001", + "00001", + "0001", + "001", + "01", + "10", + "110", + "11100000", + "11100001000", + "111000010010", + "1110000100110000", + "1110000100110001000", + "111000010011000100100", + "1110000100110001001010", + "111000010011000100101100", + "1110000100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000100110001001011001111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "0", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "0000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "0000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "0000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000100110001001011001111111", + "0000000100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "root", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "root", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "root", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "root", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "0000", + "0001", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "0000", + "0001", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "00000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000000", + "000001", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000000", + "000001", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011001111111", + "1001100010010110100000", + "1001100010010110100001", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000000", + "100110001001011010000001", + "100110001001011010000010", + "100110001001011010000011", + "100110001001011010000100", + "100110001001011010000101", + "100110001001011010000110", + "100110001001011010000111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + "1001100010010110100000", + "1001100010010110100001", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000000", + "100110001001011010000001", + "100110001001011010000010", + "100110001001011010000011", + "100110001001011010000100", + "100110001001011010000101", + "100110001001011010000110", + "100110001001011010000111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000100110001001011001111111", + "0000000100110001001011010000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "0", + "1000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "00", + "01", + "1000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "0000", + "0001", + "0010", + "0011", + "0100", + "0101", + "0110", + "0111", + "1000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000", + "001000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "0000", + "0001", + "001000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000", + "001000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000", + "0000000000000000000000000001000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + "1001100010010110100", + "100110001001011010100000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + "10011000100101101000", + "10011000100101101001", + "100110001001011010100000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + "100110001001011010000", + "100110001001011010001", + "100110001001011010010", + "100110001001011010011", + "100110001001011010100000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011001111111", + "10011000100101101000", + "10011000100101101001", + "100110001001011010100000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000100110001001011001111111", + "00000001001100010010110100", + "0000000100110001001011010100000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "0", + "10000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "00", + "01", + "100000", + "100001", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000", + "001", + "010", + "011", + "100000", + "100001", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "00000000000000000000000000", + "000000000000000000000000010000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "00000000000000000000000000", + "000000000000000000000000010000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000000000000000000000000000", + "000000000000000000000000001", + "000000000000000000000000010000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000100110001001011001111111", + "000000010011000100101101", + "00000001001100010010111", + "00000001001100010011", + "000000010011000101", + "00000001001100011", + "000000010011001", + "00000001001101", + "0000000100111", + "0000000101", + "000000011", + "0000001", + "000001", + "00001", + "0001", + "001", + "01", + "10", + "110", + "11100000", + "11100001000", + "111000010010", + "1110000100110000", + "1110000100110001000", + "111000010011000100100", + "1110000100110001001010", + "111000010011000100101100", + "1110000100110001001011010000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0", + "10", + "110", + "111000000000000000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "00", + "01", + "10", + "1100", + "1101", + "111000000000000000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000", + "001", + "010", + "011", + "100", + "101", + "110", + "111000000000000000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011010000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011010000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011010000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "100110001001011010000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011010000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011010000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011010000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011010000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000100110001001011010000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "1", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "0001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "0001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "0001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011010000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "1001100010010110100000", + "1001100010010110100001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011010000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011010000000", + "100110001001011010000001", + "100110001001011010000010", + "100110001001011010000011", + "100110001001011010000100", + "100110001001011010000101", + "100110001001011010000110", + "100110001001011010000111", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "1001100010010110100000", + "1001100010010110100001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000000", + "100110001001011010000001", + "100110001001011010000010", + "100110001001011010000011", + "100110001001011010000100", + "100110001001011010000101", + "100110001001011010000110", + "100110001001011010000111", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000100110001001011010000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000100110001001011010000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000000010011000100101101000000", + "000000010011000100101101000001", + "000000010011000100101101000010", + "000000010011000100101101000011", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000100110001001011010000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "0001", + "001", + "01", + "1000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "0001", + "0010", + "0011", + "01", + "1000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "0001", + "0010", + "0011", + "0100", + "0101", + "0110", + "0111", + "1000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000001", + "00001", + "0001", + "001000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000001", + "000010", + "000011", + "0001", + "001000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000001", + "000010", + "000011", + "000100", + "000101", + "000110", + "000111", + "001000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000001", + "000000000000000000000000000001", + "00000000000000000000000000001", + "0000000000000000000000000001000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "root", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "root", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "root", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "root", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "0000", + "0001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "0000", + "0001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000000000000000000000000000000", + "000000000000000000000000000001", + "000000000000000000000000000010", + "000000000000000000000000000011", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "1001100010010110100", + "100110001001011010100000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "10011000100101101000", + "10011000100101101001", + "100110001001011010100000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000", + "100110001001011010001", + "100110001001011010010", + "100110001001011010011", + "100110001001011010100000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "10011000100101101000", + "10011000100101101001", + "100110001001011010100000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "00000001001100010010110100", + "0000000100110001001011010100000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000001", + "00001", + "0001", + "001", + "01", + "10000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000001", + "000010", + "000011", + "0001", + "0010", + "0011", + "01", + "100000", + "100001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000001", + "000010", + "000011", + "000100", + "000101", + "000110", + "000111", + "001", + "010", + "011", + "100000", + "100001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000001", + "000000000000000000000000000001", + "00000000000000000000000000001", + "0000000000000000000000000001", + "000000000000000000000000001", + "000000000000000000000000010000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "0", + "100000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "00", + "01", + "100000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000", + "001", + "010", + "011", + "100000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "00000000000000000000000000", + "0000000000000000000000000100000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000000010011000100101101", + "00000001001100010010111", + "00000001001100010011", + "000000010011000101", + "00000001001100011", + "000000010011001", + "00000001001101", + "0000000100111", + "0000000101", + "000000011", + "0000001", + "000001", + "00001", + "0001", + "001", + "01", + "10", + "110", + "11100000", + "11100001000", + "111000010010", + "1110000100110000", + "1110000100110001000", + "111000010011000100100", + "1110000100110001001010", + "111000010011000100101100", + "1110000100110001001011010000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000001", + "000000000000000000000000000001", + "00000000000000000000000000001", + "0000000000000000000000000001", + "000000000000000000000000001", + "00000000000000000000000001", + "0000000000000000000000001", + "000000000000000000000001", + "00000000000000000000001", + "0000000000000000000001", + "000000000000000000001", + "00000000000000000001", + "0000000000000000001", + "000000000000000001", + "00000000000000001", + "0000000000000001", + "000000000000001", + "00000000000001", + "0000000000001", + "000000000001", + "00000000001", + "0000000001", + "000000001", + "00000001", + "0000001", + "000001", + "00001", + "0001", + "001", + "01", + "10", + "110", + "111000000000000000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0", + "10", + "110", + "1110000000000000000000000000000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011010000111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011010000111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011010000111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "100110001001011010000111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000100110001001011010000111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "1000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "1000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "1000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "001000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "001000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "001000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000001000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 7 }, + .expectMincoverStrings = { + "111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000111", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 7 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "00000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 7, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 7 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000111", + "100110001001011010001", + "10011000100101101001", + "100110001001011010100000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000111", + "1001100010010110100010", + "1001100010010110100011", + "10011000100101101001", + "100110001001011010100000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000111", + "100110001001011010001", + "100110001001011010010", + "100110001001011010011", + "100110001001011010100000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010000111", + "100110001001011010001000", + "100110001001011010001001", + "100110001001011010001010", + "100110001001011010001011", + "100110001001011010001100", + "100110001001011010001101", + "100110001001011010001110", + "100110001001011010001111", + "10011000100101101001", + "100110001001011010100000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000100110001001011010000111", + "0000000100110001001011010001", + "000000010011000100101101001", + "0000000100110001001011010100000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "001", + "01", + "10000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "0010", + "0011", + "01", + "100000", + "100001", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "001", + "010", + "011", + "100000", + "100001", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000001", + "000000000000000000000000001", + "000000000000000000000000010000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000001", + "0000000000000000000000000010", + "0000000000000000000000000011", + "000000000000000000000000010000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000000000000000000000000000100", + "000000000000000000000000000101", + "000000000000000000000000000110", + "000000000000000000000000000111", + "000000000000000000000000001", + "000000000000000000000000010000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000111", + "001", + "01", + "100000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000111", + "0010", + "0011", + "01", + "100000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "000111", + "001", + "010", + "011", + "100000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000111", + "0000000000000000000000000001", + "000000000000000000000000001", + "0000000000000000000000000100000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 7 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "0", + "10", + "1100", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = 7 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "00", + "01", + "10", + "1100", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = 7 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "0000", + "0001", + "0010", + "0011", + "0100", + "0101", + "0110", + "0111", + "1000", + "1001", + "1010", + "1011", + "1100", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 7 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000000000000000000000000000", + "0000000000000000000000000010", + "000000000000000000000000001100", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = 7 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000", + "0000000000000000000000000001", + "0000000000000000000000000010", + "000000000000000000000000001100", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 7 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "000000000000000000000000000", + "000000000000000000000000001000", + "000000000000000000000000001001", + "000000000000000000000000001010", + "000000000000000000000000001011", + "000000000000000000000000001100", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000100110001001011010000111", + "0000000100110001001011010001", + "000000010011000100101101001", + "00000001001100010010110101", + "0000000100110001001011011", + "00000001001100010010111", + "00000001001100010011", + "000000010011000101", + "00000001001100011", + "000000010011001", + "00000001001101", + "0000000100111", + "0000000101", + "000000011", + "0000001", + "000001", + "00001", + "0001", + "001", + "01", + "10", + "110", + "11100000", + "11100001000", + "111000010010", + "1110000100110000", + "1110000100110001000", + "111000010011000100100", + "1110000100110001001010", + "111000010011000100101100", + "1110000100110001001011010000000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000001", + "000000000000000000000000001", + "00000000000000000000000001", + "0000000000000000000000001", + "000000000000000000000001", + "00000000000000000000001", + "0000000000000000000001", + "000000000000000000001", + "00000000000000000001", + "0000000000000000001", + "000000000000000001", + "00000000000000001", + "0000000000000001", + "000000000000001", + "00000000000001", + "0000000000001", + "000000000001", + "00000000001", + "0000000001", + "000000001", + "00000001", + "0000001", + "000001", + "00001", + "0001", + "001", + "01", + "10", + "110", + "111000000000000000000000000000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000001", + "0000000000000000000000000010", + "0000000000000000000000000011", + "00000000000000000000000001", + "00000000000000000000000010", + "00000000000000000000000011", + "000000000000000000000001", + "000000000000000000000010", + "000000000000000000000011", + "0000000000000000000001", + "0000000000000000000010", + "0000000000000000000011", + "00000000000000000001", + "00000000000000000010", + "00000000000000000011", + "000000000000000001", + "000000000000000010", + "000000000000000011", + "0000000000000001", + "0000000000000010", + "0000000000000011", + "00000000000001", + "00000000000010", + "00000000000011", + "000000000001", + "000000000010", + "000000000011", + "0000000001", + "0000000010", + "0000000011", + "00000001", + "00000010", + "00000011", + "000001", + "000010", + "000011", + "0001", + "0010", + "0011", + "01", + "10", + "1100", + "1101", + "111000000000000000000000000000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000111", + "0000000000000000000000000001", + "000000000000000000000000001", + "00000000000000000000000001", + "0000000000000000000000001", + "000000000000000000000001", + "00000000000000000000001", + "0000000000000000000001", + "000000000000000000001", + "00000000000000000001", + "0000000000000000001", + "000000000000000001", + "00000000000000001", + "0000000000000001", + "000000000000001", + "00000000000001", + "0000000000001", + "000000000001", + "00000000001", + "0000000001", + "000000001", + "00000001", + "0000001", + "000001", + "00001", + "0001", + "001", + "01", + "10", + "110", + "1110000000000000000000000000000", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 7 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0", + "10", + "1100", + "11010", + "110110", + "1101110", + "11011110", + "110111110", + "1101111110", + "11011111110", + "110111111110", + "1101111111110", + "11011111111110", + "110111111111110", + "1101111111111110", + "11011111111111110", + "110111111111111110", + "1101111111111111110", + "11011111111111111110", + "110111111111111111110", + "1101111111111111111110", + "11011111111111111111110", + "110111111111111111111110", + "1101111111111111111111110", + "11011111111111111111111110", + "110111111111111111111111110", + "1101111111111111111111111110", + "110111111111111111111111111100", + }, +}, +{ + .lowerBound = 7, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = 7 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "00", + "01", + "10", + "1100", + "110100", + "110101", + "110110", + "11011100", + "11011101", + "11011110", + "1101111100", + "1101111101", + "1101111110", + "110111111100", + "110111111101", + "110111111110", + "11011111111100", + "11011111111101", + "11011111111110", + "1101111111111100", + "1101111111111101", + "1101111111111110", + "110111111111111100", + "110111111111111101", + "110111111111111110", + "11011111111111111100", + "11011111111111111101", + "11011111111111111110", + "1101111111111111111100", + "1101111111111111111101", + "1101111111111111111110", + "110111111111111111111100", + "110111111111111111111101", + "110111111111111111111110", + "11011111111111111111111100", + "11011111111111111111111101", + "11011111111111111111111110", + "1101111111111111111111111100", + "1101111111111111111111111101", + "1101111111111111111111111110", + "110111111111111111111111111100", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010100000", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010100000", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010100000", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100110001001011010100000", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000100110001001011010100000", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100001", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100001", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100001", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000100001", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100000", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100000", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "100000", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000100000", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 7 }, + .max = { .set = true, .value = 32 }, + .expectMincoverStrings = { + "11001", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 7 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000011001", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 32, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 32 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000000000", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "00000001001100010010110101", + "0000000100110001001011011", + "00000001001100010010111", + "00000001001100010011", + "000000010011000101", + "00000001001100011", + "000000010011001", + "00000001001101", + "0000000100111", + "0000000101", + "000000011", + "0000001", + "000001", + "00001", + "0001", + "001", + "01", + "10", + "110", + "11100000", + "11100001000", + "111000010010", + "1110000100110000", + "1110000100110001000", + "111000010011000100100", + "1110000100110001001010", + "111000010011000100101100", + "1110000100110001001011010000000", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0000000000000000000000000100001", + "000000000000000000000000010001", + "00000000000000000000000001001", + "0000000000000000000000000101", + "000000000000000000000000011", + "0000000000000000000000001", + "000000000000000000000001", + "00000000000000000000001", + "0000000000000000000001", + "000000000000000000001", + "00000000000000000001", + "0000000000000000001", + "000000000000000001", + "00000000000000001", + "0000000000000001", + "000000000000001", + "00000000000001", + "0000000000001", + "000000000001", + "00000000001", + "0000000001", + "000000001", + "00000001", + "0000001", + "000001", + "00001", + "0001", + "001", + "01", + "10", + "110", + "111000000000000000000000000000", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "00000000000000000000000001", + "0000000000000000000000001", + "000000000000000000000001", + "00000000000000000000001", + "0000000000000000000001", + "000000000000000000001", + "00000000000000000001", + "0000000000000000001", + "000000000000000001", + "00000000000000001", + "0000000000000001", + "000000000000001", + "00000000000001", + "0000000000001", + "000000000001", + "00000000001", + "0000000001", + "000000001", + "00000001", + "0000001", + "000001", + "00001", + "0001", + "001", + "01", + "10", + "110", + "1110000000000000000000000000000", + }, +}, +{ + .lowerBound = 32, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 32 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "0", + "10", + "1100", + "11010", + "110110", + "1101110", + "11011110", + "110111110", + "1101111110", + "11011111110", + "110111111110", + "1101111111110", + "11011111111110", + "110111111111110", + "1101111111111110", + "11011111111111110", + "110111111111111110", + "1101111111111111110", + "11011111111111111110", + "110111111111111111110", + "1101111111111111111110", + "11011111111111111111110", + "110111111111111111111110", + "1101111111111111111111110", + "11011111111111111111111110", + "1101111111111111111111111100000", + }, +}, +{ + .lowerBound = 1879048192, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -10000000 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "1110000100110001001011010000000", + }, +}, +{ + .lowerBound = 1879048192, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "1110000000000000000000000000001", + }, +}, +{ + .lowerBound = 1879048192, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "1110000000000000000000000000000", + }, +}, +{ + .lowerBound = 1879048192, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 7 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "1101111111111111111111111111001", + }, +}, +{ + .lowerBound = 1879048192, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 32 }, + .max = { .set = true, .value = 1879048192 }, + .expectMincoverStrings = { + "1101111111111111111111111100000", + }, }, diff --git a/test/data/range-min-cover/mincover_int64.cstruct b/test/data/range-min-cover/mincover_int64.cstruct index e8edc041b..2b16928ec 100644 --- a/test/data/range-min-cover/mincover_int64.cstruct +++ b/test/data/range-min-cover/mincover_int64.cstruct @@ -1,3019 +1,3398 @@ -// This is a copy of test vectors from the mongodb/mongo repository. -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(-1), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001100111111110011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(-1), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001100111111110011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(0), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001100111111110011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(0), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001100111111110011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001100111111110011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001100111111110011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111110011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -100, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111110011100\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(-1), - .sparsity = 1, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101\n" \ - "11100011010111111010100100110001100111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(-1), - .sparsity = 2, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "1110001101011111101010010011000110011111111010\n" \ - "1110001101011111101010010011000110011111111011\n" \ - "11100011010111111010100100110001100111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(-1), - .sparsity = 3, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101\n" \ - "111000110101111110101001001100011001111111110\n" \ - "111000110101111110101001001100011001111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(-1), - .sparsity = 4, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101000\n" \ - "111000110101111110101001001100011001111111101001\n" \ - "111000110101111110101001001100011001111111101010\n" \ - "111000110101111110101001001100011001111111101011\n" \ - "111000110101111110101001001100011001111111101100\n" \ - "111000110101111110101001001100011001111111101101\n" \ - "111000110101111110101001001100011001111111101110\n" \ - "111000110101111110101001001100011001111111101111\n" \ - "11100011010111111010100100110001100111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(0), - .sparsity = 1, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101\n" \ - "11100011010111111010100100110001100111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(0), - .sparsity = 2, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "1110001101011111101010010011000110011111111010\n" \ - "1110001101011111101010010011000110011111111011\n" \ - "11100011010111111010100100110001100111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(0), - .sparsity = 3, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101\n" \ - "111000110101111110101001001100011001111111110\n" \ - "111000110101111110101001001100011001111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(0), - .sparsity = 4, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101000\n" \ - "111000110101111110101001001100011001111111101001\n" \ - "111000110101111110101001001100011001111111101010\n" \ - "111000110101111110101001001100011001111111101011\n" \ - "111000110101111110101001001100011001111111101100\n" \ - "111000110101111110101001001100011001111111101101\n" \ - "111000110101111110101001001100011001111111101110\n" \ - "111000110101111110101001001100011001111111101111\n" \ - "11100011010111111010100100110001100111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101\n" \ - "11100011010111111010100100110001100111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "1110001101011111101010010011000110011111111010\n" \ - "1110001101011111101010010011000110011111111011\n" \ - "11100011010111111010100100110001100111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 3, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101\n" \ - "111000110101111110101001001100011001111111110\n" \ - "111000110101111110101001001100011001111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 4, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101000\n" \ - "111000110101111110101001001100011001111111101001\n" \ - "111000110101111110101001001100011001111111101010\n" \ - "111000110101111110101001001100011001111111101011\n" \ - "111000110101111110101001001100011001111111101100\n" \ - "111000110101111110101001001100011001111111101101\n" \ - "111000110101111110101001001100011001111111101110\n" \ - "111000110101111110101001001100011001111111101111\n" \ - "11100011010111111010100100110001100111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "0000000000000111000110101111110101001001100011001111111100111\n" \ - "0000000000000111000110101111110101001001100011001111111101\n" \ - "000000000000011100011010111111010100100110001100111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 2, - .expectMincoverString = "00000000000001110001101011111101010010011000110011111111001110\n" \ - "00000000000001110001101011111101010010011000110011111111001111\n" \ - "0000000000000111000110101111110101001001100011001111111101\n" \ - "0000000000000111000110101111110101001001100011001111111110\n" \ - "0000000000000111000110101111110101001001100011001111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111110011100\n" \ - "000000000000011100011010111111010100100110001100111111110011101\n" \ - "000000000000011100011010111111010100100110001100111111110011110\n" \ - "000000000000011100011010111111010100100110001100111111110011111\n" \ - "000000000000011100011010111111010100100110001100111111110100\n" \ - "000000000000011100011010111111010100100110001100111111110101\n" \ - "000000000000011100011010111111010100100110001100111111110110\n" \ - "000000000000011100011010111111010100100110001100111111110111\n" \ - "000000000000011100011010111111010100100110001100111111111\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(0), - .sparsity = 1, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101\n" \ - "11100011010111111010100100110001100111111111\n" \ - "11100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(0), - .sparsity = 2, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "1110001101011111101010010011000110011111111010\n" \ - "1110001101011111101010010011000110011111111011\n" \ - "11100011010111111010100100110001100111111111\n" \ - "11100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101\n" \ - "11100011010111111010100100110001100111111111\n" \ - "11100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "1110001101011111101010010011000110011111111010\n" \ - "1110001101011111101010010011000110011111111011\n" \ - "11100011010111111010100100110001100111111111\n" \ - "11100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "0000000000000111000110101111110101001001100011001111111100111\n" \ - "0000000000000111000110101111110101001001100011001111111101\n" \ - "000000000000011100011010111111010100100110001100111111111\n" \ - "000000000000011100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111110011100\n" \ - "000000000000011100011010111111010100100110001100111111110011101\n" \ - "000000000000011100011010111111010100100110001100111111110011110\n" \ - "000000000000011100011010111111010100100110001100111111110011111\n" \ - "000000000000011100011010111111010100100110001100111111110100\n" \ - "000000000000011100011010111111010100100110001100111111110101\n" \ - "000000000000011100011010111111010100100110001100111111110110\n" \ - "000000000000011100011010111111010100100110001100111111110111\n" \ - "000000000000011100011010111111010100100110001100111111111\n" \ - "000000000000011100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101\n" \ - "11100011010111111010100100110001100111111111\n" \ - "11100011010111111010100100110001101000000\n" \ - "111000110101111110101001001100011010000010\n" \ - "111000110101111110101001001100011010000011000\n" \ - "1110001101011111101010010011000110100000110010\n" \ - "11100011010111111010100100110001101000001100110\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "1110001101011111101010010011000110011111111010\n" \ - "1110001101011111101010010011000110011111111011\n" \ - "11100011010111111010100100110001100111111111\n" \ - "111000110101111110101001001100011010000000\n" \ - "111000110101111110101001001100011010000001\n" \ - "111000110101111110101001001100011010000010\n" \ - "1110001101011111101010010011000110100000110000\n" \ - "1110001101011111101010010011000110100000110001\n" \ - "1110001101011111101010010011000110100000110010\n" \ - "111000110101111110101001001100011010000011001100\n" \ - "111000110101111110101001001100011010000011001101\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 3, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101\n" \ - "111000110101111110101001001100011001111111110\n" \ - "111000110101111110101001001100011001111111111\n" \ - "111000110101111110101001001100011010000000\n" \ - "111000110101111110101001001100011010000001\n" \ - "111000110101111110101001001100011010000010\n" \ - "111000110101111110101001001100011010000011000\n" \ - "111000110101111110101001001100011010000011001000\n" \ - "111000110101111110101001001100011010000011001001\n" \ - "111000110101111110101001001100011010000011001010\n" \ - "111000110101111110101001001100011010000011001011\n" \ - "111000110101111110101001001100011010000011001100\n" \ - "111000110101111110101001001100011010000011001101\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 4, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101000\n" \ - "111000110101111110101001001100011001111111101001\n" \ - "111000110101111110101001001100011001111111101010\n" \ - "111000110101111110101001001100011001111111101011\n" \ - "111000110101111110101001001100011001111111101100\n" \ - "111000110101111110101001001100011001111111101101\n" \ - "111000110101111110101001001100011001111111101110\n" \ - "111000110101111110101001001100011001111111101111\n" \ - "11100011010111111010100100110001100111111111\n" \ - "11100011010111111010100100110001101000000000\n" \ - "11100011010111111010100100110001101000000001\n" \ - "11100011010111111010100100110001101000000010\n" \ - "11100011010111111010100100110001101000000011\n" \ - "11100011010111111010100100110001101000000100\n" \ - "11100011010111111010100100110001101000000101\n" \ - "11100011010111111010100100110001101000000110\n" \ - "11100011010111111010100100110001101000000111\n" \ - "11100011010111111010100100110001101000001000\n" \ - "11100011010111111010100100110001101000001001\n" \ - "11100011010111111010100100110001101000001010\n" \ - "11100011010111111010100100110001101000001011\n" \ - "111000110101111110101001001100011010000011000000\n" \ - "111000110101111110101001001100011010000011000001\n" \ - "111000110101111110101001001100011010000011000010\n" \ - "111000110101111110101001001100011010000011000011\n" \ - "111000110101111110101001001100011010000011000100\n" \ - "111000110101111110101001001100011010000011000101\n" \ - "111000110101111110101001001100011010000011000110\n" \ - "111000110101111110101001001100011010000011000111\n" \ - "111000110101111110101001001100011010000011001000\n" \ - "111000110101111110101001001100011010000011001001\n" \ - "111000110101111110101001001100011010000011001010\n" \ - "111000110101111110101001001100011010000011001011\n" \ - "111000110101111110101001001100011010000011001100\n" \ - "111000110101111110101001001100011010000011001101\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "0000000000000111000110101111110101001001100011001111111100111\n" \ - "0000000000000111000110101111110101001001100011001111111101\n" \ - "000000000000011100011010111111010100100110001100111111111\n" \ - "000000000000011100011010111111010100100110001101000000\n" \ - "0000000000000111000110101111110101001001100011010000010\n" \ - "0000000000000111000110101111110101001001100011010000011000\n" \ - "00000000000001110001101011111101010010011000110100000110010\n" \ - "000000000000011100011010111111010100100110001101000001100110\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 2, - .expectMincoverString = "00000000000001110001101011111101010010011000110011111111001110\n" \ - "00000000000001110001101011111101010010011000110011111111001111\n" \ - "0000000000000111000110101111110101001001100011001111111101\n" \ - "0000000000000111000110101111110101001001100011001111111110\n" \ - "0000000000000111000110101111110101001001100011001111111111\n" \ - "000000000000011100011010111111010100100110001101000000\n" \ - "00000000000001110001101011111101010010011000110100000100\n" \ - "00000000000001110001101011111101010010011000110100000101\n" \ - "0000000000000111000110101111110101001001100011010000011000\n" \ - "000000000000011100011010111111010100100110001101000001100100\n" \ - "000000000000011100011010111111010100100110001101000001100101\n" \ - "000000000000011100011010111111010100100110001101000001100110\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111110011100\n" \ - "000000000000011100011010111111010100100110001100111111110011101\n" \ - "000000000000011100011010111111010100100110001100111111110011110\n" \ - "000000000000011100011010111111010100100110001100111111110011111\n" \ - "000000000000011100011010111111010100100110001100111111110100\n" \ - "000000000000011100011010111111010100100110001100111111110101\n" \ - "000000000000011100011010111111010100100110001100111111110110\n" \ - "000000000000011100011010111111010100100110001100111111110111\n" \ - "000000000000011100011010111111010100100110001100111111111\n" \ - "000000000000011100011010111111010100100110001101000000\n" \ - "000000000000011100011010111111010100100110001101000001000\n" \ - "000000000000011100011010111111010100100110001101000001001\n" \ - "000000000000011100011010111111010100100110001101000001010\n" \ - "000000000000011100011010111111010100100110001101000001011\n" \ - "000000000000011100011010111111010100100110001101000001100000\n" \ - "000000000000011100011010111111010100100110001101000001100001\n" \ - "000000000000011100011010111111010100100110001101000001100010\n" \ - "000000000000011100011010111111010100100110001101000001100011\n" \ - "000000000000011100011010111111010100100110001101000001100100\n" \ - "000000000000011100011010111111010100100110001101000001100101\n" \ - "000000000000011100011010111111010100100110001101000001100110\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "111000110101111110101001001100011001111111101\n" \ - "11100011010111111010100100110001100111111111\n" \ - "1110001101011111101010010011000110100000\n" \ - "11100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "111000110101111110101001001100011001111111100111\n" \ - "1110001101011111101010010011000110011111111010\n" \ - "1110001101011111101010010011000110011111111011\n" \ - "11100011010111111010100100110001100111111111\n" \ - "1110001101011111101010010011000110100000\n" \ - "11100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "0000000000000111000110101111110101001001100011001111111100111\n" \ - "0000000000000111000110101111110101001001100011001111111101\n" \ - "000000000000011100011010111111010100100110001100111111111\n" \ - "00000000000001110001101011111101010010011000110100000\n" \ - "000000000000011100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111110011100\n" \ - "000000000000011100011010111111010100100110001100111111110011101\n" \ - "000000000000011100011010111111010100100110001100111111110011110\n" \ - "000000000000011100011010111111010100100110001100111111110011111\n" \ - "000000000000011100011010111111010100100110001100111111110100\n" \ - "000000000000011100011010111111010100100110001100111111110101\n" \ - "000000000000011100011010111111010100100110001100111111110110\n" \ - "000000000000011100011010111111010100100110001100111111110111\n" \ - "000000000000011100011010111111010100100110001100111111111\n" \ - "000000000000011100011010111111010100100110001101000000\n" \ - "000000000000011100011010111111010100100110001101000001\n" \ - "000000000000011100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "0000000000000111000110101111110101001001100011001111111100111\n" \ - "0000000000000111000110101111110101001001100011001111111101\n" \ - "000000000000011100011010111111010100100110001100111111111\n" \ - "000000000000011100011010111111010100100110001101\n" \ - "00000000000001110001101011111101010010011000111\n" \ - "00000000000001110001101011111101010010011001\n" \ - "0000000000000111000110101111110101001001101\n" \ - "000000000000011100011010111111010100100111\n" \ - "000000000000011100011010111111010100101\n" \ - "00000000000001110001101011111101010011\n" \ - "000000000000011100011010111111010101\n" \ - "00000000000001110001101011111101011\n" \ - "000000000000011100011010111111011\n" \ - "00000000000001110001101011111110000\n" \ - "0000000000000111000110101111111000100\n" \ - "0000000000000111000110101111111000101000\n" \ - "00000000000001110001101011111110001010010\n" \ - "000000000000011100011010111111100010100110000\n" \ - "0000000000000111000110101111111000101001100010\n" \ - "000000000000011100011010111111100010100110001100\n" \ - "000000000000011100011010111111100010100110001101000000000000000\n" -}, -{ - .lowerBound = -100, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111110011100\n" \ - "000000000000011100011010111111010100100110001100111111110011101\n" \ - "000000000000011100011010111111010100100110001100111111110011110\n" \ - "000000000000011100011010111111010100100110001100111111110011111\n" \ - "000000000000011100011010111111010100100110001100111111110100\n" \ - "000000000000011100011010111111010100100110001100111111110101\n" \ - "000000000000011100011010111111010100100110001100111111110110\n" \ - "000000000000011100011010111111010100100110001100111111110111\n" \ - "000000000000011100011010111111010100100110001100111111111\n" \ - "000000000000011100011010111111010100100110001101\n" \ - "000000000000011100011010111111010100100110001110\n" \ - "000000000000011100011010111111010100100110001111\n" \ - "000000000000011100011010111111010100100110010\n" \ - "000000000000011100011010111111010100100110011\n" \ - "000000000000011100011010111111010100100110100\n" \ - "000000000000011100011010111111010100100110101\n" \ - "000000000000011100011010111111010100100110110\n" \ - "000000000000011100011010111111010100100110111\n" \ - "000000000000011100011010111111010100100111\n" \ - "000000000000011100011010111111010100101\n" \ - "000000000000011100011010111111010100110\n" \ - "000000000000011100011010111111010100111\n" \ - "000000000000011100011010111111010101\n" \ - "000000000000011100011010111111010110\n" \ - "000000000000011100011010111111010111\n" \ - "000000000000011100011010111111011\n" \ - "000000000000011100011010111111100000\n" \ - "000000000000011100011010111111100001\n" \ - "000000000000011100011010111111100010000\n" \ - "000000000000011100011010111111100010001\n" \ - "000000000000011100011010111111100010010\n" \ - "000000000000011100011010111111100010011\n" \ - "000000000000011100011010111111100010100000\n" \ - "000000000000011100011010111111100010100001\n" \ - "000000000000011100011010111111100010100010\n" \ - "000000000000011100011010111111100010100011\n" \ - "000000000000011100011010111111100010100100\n" \ - "000000000000011100011010111111100010100101\n" \ - "000000000000011100011010111111100010100110000\n" \ - "000000000000011100011010111111100010100110001000\n" \ - "000000000000011100011010111111100010100110001001\n" \ - "000000000000011100011010111111100010100110001010\n" \ - "000000000000011100011010111111100010100110001011\n" \ - "000000000000011100011010111111100010100110001100\n" \ - "000000000000011100011010111111100010100110001101000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(-1), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001100111111111111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(-1), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001100111111111111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(0), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001100111111111111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(0), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001100111111111111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001100111111111111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001100111111111111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111111111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111111111111\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(0), - .sparsity = 1, - .expectMincoverString = "0\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "00000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = -1, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(0), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001100111111111111111\n" \ - "11100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(0), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001100111111111111111\n" \ - "11100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001100111111111111111\n" \ - "11100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001100111111111111111\n" \ - "11100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111111111111\n" \ - "000000000000011100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111111111111\n" \ - "000000000000011100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(0), - .sparsity = 1, - .expectMincoverString = "root\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(0), - .sparsity = 2, - .expectMincoverString = "root\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(0), - .sparsity = 3, - .expectMincoverString = "root\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(0), - .sparsity = 4, - .expectMincoverString = "root\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "0000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "0000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "00000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 2, - .expectMincoverString = "00000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000000000000\n" \ - "000000000000000000000000000000000000000000000000000000000000001\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001100111111111111111\n" \ - "11100011010111111010100100110001101000000\n" \ - "111000110101111110101001001100011010000010\n" \ - "111000110101111110101001001100011010000011000\n" \ - "1110001101011111101010010011000110100000110010\n" \ - "11100011010111111010100100110001101000001100110\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001100111111111111111\n" \ - "111000110101111110101001001100011010000000\n" \ - "111000110101111110101001001100011010000001\n" \ - "111000110101111110101001001100011010000010\n" \ - "1110001101011111101010010011000110100000110000\n" \ - "1110001101011111101010010011000110100000110001\n" \ - "1110001101011111101010010011000110100000110010\n" \ - "111000110101111110101001001100011010000011001100\n" \ - "111000110101111110101001001100011010000011001101\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111111111111\n" \ - "000000000000011100011010111111010100100110001101000000\n" \ - "0000000000000111000110101111110101001001100011010000010\n" \ - "0000000000000111000110101111110101001001100011010000011000\n" \ - "00000000000001110001101011111101010010011000110100000110010\n" \ - "000000000000011100011010111111010100100110001101000001100110\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111111111111\n" \ - "000000000000011100011010111111010100100110001101000000\n" \ - "000000000000011100011010111111010100100110001101000001000\n" \ - "000000000000011100011010111111010100100110001101000001001\n" \ - "000000000000011100011010111111010100100110001101000001010\n" \ - "000000000000011100011010111111010100100110001101000001011\n" \ - "000000000000011100011010111111010100100110001101000001100000\n" \ - "000000000000011100011010111111010100100110001101000001100001\n" \ - "000000000000011100011010111111010100100110001101000001100010\n" \ - "000000000000011100011010111111010100100110001101000001100011\n" \ - "000000000000011100011010111111010100100110001101000001100100\n" \ - "000000000000011100011010111111010100100110001101000001100101\n" \ - "000000000000011100011010111111010100100110001101000001100110\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "00\n" \ - "010\n" \ - "011000\n" \ - "0110010\n" \ - "01100110\n" \ - "01100111000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000\n" \ - "0000000000000000000000000000000000000000000000000000010\n" \ - "0000000000000000000000000000000000000000000000000000011000\n" \ - "00000000000000000000000000000000000000000000000000000110010\n" \ - "000000000000000000000000000000000000000000000000000001100110\n" \ - "000000000000000000000000000000000000000000000000000001100111000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000\n" \ - "000000000000000000000000000000000000000000000000000001000\n" \ - "000000000000000000000000000000000000000000000000000001001\n" \ - "000000000000000000000000000000000000000000000000000001010\n" \ - "000000000000000000000000000000000000000000000000000001011\n" \ - "000000000000000000000000000000000000000000000000000001100000\n" \ - "000000000000000000000000000000000000000000000000000001100001\n" \ - "000000000000000000000000000000000000000000000000000001100010\n" \ - "000000000000000000000000000000000000000000000000000001100011\n" \ - "000000000000000000000000000000000000000000000000000001100100\n" \ - "000000000000000000000000000000000000000000000000000001100101\n" \ - "000000000000000000000000000000000000000000000000000001100110\n" \ - "000000000000000000000000000000000000000000000000000001100111000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001100111111111111111\n" \ - "1110001101011111101010010011000110100000\n" \ - "11100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001100111111111111111\n" \ - "1110001101011111101010010011000110100000\n" \ - "11100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111111111111\n" \ - "00000000000001110001101011111101010010011000110100000\n" \ - "000000000000011100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111111111111\n" \ - "000000000000011100011010111111010100100110001101000000\n" \ - "000000000000011100011010111111010100100110001101000001\n" \ - "000000000000011100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "0\n" \ - "1000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "00\n" \ - "01\n" \ - "1000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "00000000000000000000000000000000000000000000000000000\n" \ - "00000000000000000000000000000000000000000000000000001000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 2, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000\n" \ - "000000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000000001000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000\n" \ - "000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000010000000000\n" \ - "000000000000000000000000000000000000000000000000000010000000001\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111111111111\n" \ - "000000000000011100011010111111010100100110001101\n" \ - "00000000000001110001101011111101010010011000111\n" \ - "00000000000001110001101011111101010010011001\n" \ - "0000000000000111000110101111110101001001101\n" \ - "000000000000011100011010111111010100100111\n" \ - "000000000000011100011010111111010100101\n" \ - "00000000000001110001101011111101010011\n" \ - "000000000000011100011010111111010101\n" \ - "00000000000001110001101011111101011\n" \ - "000000000000011100011010111111011\n" \ - "00000000000001110001101011111110000\n" \ - "0000000000000111000110101111111000100\n" \ - "0000000000000111000110101111111000101000\n" \ - "00000000000001110001101011111110001010010\n" \ - "000000000000011100011010111111100010100110000\n" \ - "0000000000000111000110101111111000101001100010\n" \ - "000000000000011100011010111111100010100110001100\n" \ - "000000000000011100011010111111100010100110001101000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001100111111111111111\n" \ - "000000000000011100011010111111010100100110001101\n" \ - "000000000000011100011010111111010100100110001110\n" \ - "000000000000011100011010111111010100100110001111\n" \ - "000000000000011100011010111111010100100110010\n" \ - "000000000000011100011010111111010100100110011\n" \ - "000000000000011100011010111111010100100110100\n" \ - "000000000000011100011010111111010100100110101\n" \ - "000000000000011100011010111111010100100110110\n" \ - "000000000000011100011010111111010100100110111\n" \ - "000000000000011100011010111111010100100111\n" \ - "000000000000011100011010111111010100101\n" \ - "000000000000011100011010111111010100110\n" \ - "000000000000011100011010111111010100111\n" \ - "000000000000011100011010111111010101\n" \ - "000000000000011100011010111111010110\n" \ - "000000000000011100011010111111010111\n" \ - "000000000000011100011010111111011\n" \ - "000000000000011100011010111111100000\n" \ - "000000000000011100011010111111100001\n" \ - "000000000000011100011010111111100010000\n" \ - "000000000000011100011010111111100010001\n" \ - "000000000000011100011010111111100010010\n" \ - "000000000000011100011010111111100010011\n" \ - "000000000000011100011010111111100010100000\n" \ - "000000000000011100011010111111100010100001\n" \ - "000000000000011100011010111111100010100010\n" \ - "000000000000011100011010111111100010100011\n" \ - "000000000000011100011010111111100010100100\n" \ - "000000000000011100011010111111100010100101\n" \ - "000000000000011100011010111111100010100110000\n" \ - "000000000000011100011010111111100010100110001000\n" \ - "000000000000011100011010111111100010100110001001\n" \ - "000000000000011100011010111111100010100110001010\n" \ - "000000000000011100011010111111100010100110001011\n" \ - "000000000000011100011010111111100010100110001100\n" \ - "000000000000011100011010111111100010100110001101000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000\n" \ - "0000000000000000000000000000000010\n" \ - "00000000000000000000000000000000110\n" \ - "00000000000000000000000000000000111000000000000000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 2, - .expectMincoverString = "0000000000000000000000000000000000\n" \ - "0000000000000000000000000000000001\n" \ - "0000000000000000000000000000000010\n" \ - "000000000000000000000000000000001100\n" \ - "000000000000000000000000000000001101\n" \ - "00000000000000000000000000000000111000000000000000000000000000\n" -}, -{ - .lowerBound = -1, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000\n" \ - "000000000000000000000000000000001000\n" \ - "000000000000000000000000000000001001\n" \ - "000000000000000000000000000000001010\n" \ - "000000000000000000000000000000001011\n" \ - "000000000000000000000000000000001100\n" \ - "000000000000000000000000000000001101\n" \ - "000000000000000000000000000000001110000000000000000000000000000\n" \ - "000000000000000000000000000000001110000000000000000000000000001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(0), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(0), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000011100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001101000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(0), - .sparsity = 1, - .expectMincoverString = "1\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "00000000001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000000000001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000000000001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "00000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 0, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001101000000\n" \ - "111000110101111110101001001100011010000010\n" \ - "111000110101111110101001001100011010000011000\n" \ - "1110001101011111101010010011000110100000110010\n" \ - "11100011010111111010100100110001101000001100110\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "111000110101111110101001001100011010000000\n" \ - "111000110101111110101001001100011010000001\n" \ - "111000110101111110101001001100011010000010\n" \ - "1110001101011111101010010011000110100000110000\n" \ - "1110001101011111101010010011000110100000110001\n" \ - "1110001101011111101010010011000110100000110010\n" \ - "111000110101111110101001001100011010000011001100\n" \ - "111000110101111110101001001100011010000011001101\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 3, - .expectMincoverString = "111000110101111110101001001100011010000000\n" \ - "111000110101111110101001001100011010000001\n" \ - "111000110101111110101001001100011010000010\n" \ - "111000110101111110101001001100011010000011000\n" \ - "111000110101111110101001001100011010000011001000\n" \ - "111000110101111110101001001100011010000011001001\n" \ - "111000110101111110101001001100011010000011001010\n" \ - "111000110101111110101001001100011010000011001011\n" \ - "111000110101111110101001001100011010000011001100\n" \ - "111000110101111110101001001100011010000011001101\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 4, - .expectMincoverString = "11100011010111111010100100110001101000000000\n" \ - "11100011010111111010100100110001101000000001\n" \ - "11100011010111111010100100110001101000000010\n" \ - "11100011010111111010100100110001101000000011\n" \ - "11100011010111111010100100110001101000000100\n" \ - "11100011010111111010100100110001101000000101\n" \ - "11100011010111111010100100110001101000000110\n" \ - "11100011010111111010100100110001101000000111\n" \ - "11100011010111111010100100110001101000001000\n" \ - "11100011010111111010100100110001101000001001\n" \ - "11100011010111111010100100110001101000001010\n" \ - "11100011010111111010100100110001101000001011\n" \ - "111000110101111110101001001100011010000011000000\n" \ - "111000110101111110101001001100011010000011000001\n" \ - "111000110101111110101001001100011010000011000010\n" \ - "111000110101111110101001001100011010000011000011\n" \ - "111000110101111110101001001100011010000011000100\n" \ - "111000110101111110101001001100011010000011000101\n" \ - "111000110101111110101001001100011010000011000110\n" \ - "111000110101111110101001001100011010000011000111\n" \ - "111000110101111110101001001100011010000011001000\n" \ - "111000110101111110101001001100011010000011001001\n" \ - "111000110101111110101001001100011010000011001010\n" \ - "111000110101111110101001001100011010000011001011\n" \ - "111000110101111110101001001100011010000011001100\n" \ - "111000110101111110101001001100011010000011001101\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000011100011010111111010100100110001101000000\n" \ - "0000000000000111000110101111110101001001100011010000010\n" \ - "0000000000000111000110101111110101001001100011010000011000\n" \ - "00000000000001110001101011111101010010011000110100000110010\n" \ - "000000000000011100011010111111010100100110001101000001100110\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 2, - .expectMincoverString = "000000000000011100011010111111010100100110001101000000\n" \ - "00000000000001110001101011111101010010011000110100000100\n" \ - "00000000000001110001101011111101010010011000110100000101\n" \ - "0000000000000111000110101111110101001001100011010000011000\n" \ - "000000000000011100011010111111010100100110001101000001100100\n" \ - "000000000000011100011010111111010100100110001101000001100101\n" \ - "000000000000011100011010111111010100100110001101000001100110\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001101000000\n" \ - "000000000000011100011010111111010100100110001101000001000\n" \ - "000000000000011100011010111111010100100110001101000001001\n" \ - "000000000000011100011010111111010100100110001101000001010\n" \ - "000000000000011100011010111111010100100110001101000001011\n" \ - "000000000000011100011010111111010100100110001101000001100000\n" \ - "000000000000011100011010111111010100100110001101000001100001\n" \ - "000000000000011100011010111111010100100110001101000001100010\n" \ - "000000000000011100011010111111010100100110001101000001100011\n" \ - "000000000000011100011010111111010100100110001101000001100100\n" \ - "000000000000011100011010111111010100100110001101000001100101\n" \ - "000000000000011100011010111111010100100110001101000001100110\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 4, - .expectMincoverString = "00000000000001110001101011111101010010011000110100000000\n" \ - "00000000000001110001101011111101010010011000110100000001\n" \ - "00000000000001110001101011111101010010011000110100000010\n" \ - "00000000000001110001101011111101010010011000110100000011\n" \ - "00000000000001110001101011111101010010011000110100000100\n" \ - "00000000000001110001101011111101010010011000110100000101\n" \ - "000000000000011100011010111111010100100110001101000001100000\n" \ - "000000000000011100011010111111010100100110001101000001100001\n" \ - "000000000000011100011010111111010100100110001101000001100010\n" \ - "000000000000011100011010111111010100100110001101000001100011\n" \ - "000000000000011100011010111111010100100110001101000001100100\n" \ - "000000000000011100011010111111010100100110001101000001100101\n" \ - "000000000000011100011010111111010100100110001101000001100110\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "00000000001\n" \ - "0000000001\n" \ - "000000001\n" \ - "00000001\n" \ - "0000001\n" \ - "000001\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "010\n" \ - "011000\n" \ - "0110010\n" \ - "01100110\n" \ - "01100111000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000000010\n" \ - "0000000000000000000000000000000000000000000000000000011000\n" \ - "00000000000000000000000000000000000000000000000000000110010\n" \ - "000000000000000000000000000000000000000000000000000001100110\n" \ - "000000000000000000000000000000000000000000000000000001100111000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000000000000010\n" \ - "000000000000000000000000000000000000000000000000000000000000011\n" \ - "000000000000000000000000000000000000000000000000000000000000100\n" \ - "000000000000000000000000000000000000000000000000000000000000101\n" \ - "000000000000000000000000000000000000000000000000000000000000110\n" \ - "000000000000000000000000000000000000000000000000000000000000111\n" \ - "000000000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000000000010\n" \ - "000000000000000000000000000000000000000000000000000000000011\n" \ - "000000000000000000000000000000000000000000000000000000000100\n" \ - "000000000000000000000000000000000000000000000000000000000101\n" \ - "000000000000000000000000000000000000000000000000000000000110\n" \ - "000000000000000000000000000000000000000000000000000000000111\n" \ - "000000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000000010\n" \ - "000000000000000000000000000000000000000000000000000000011\n" \ - "000000000000000000000000000000000000000000000000000000100\n" \ - "000000000000000000000000000000000000000000000000000000101\n" \ - "000000000000000000000000000000000000000000000000000000110\n" \ - "000000000000000000000000000000000000000000000000000000111\n" \ - "000000000000000000000000000000000000000000000000000001000\n" \ - "000000000000000000000000000000000000000000000000000001001\n" \ - "000000000000000000000000000000000000000000000000000001010\n" \ - "000000000000000000000000000000000000000000000000000001011\n" \ - "000000000000000000000000000000000000000000000000000001100000\n" \ - "000000000000000000000000000000000000000000000000000001100001\n" \ - "000000000000000000000000000000000000000000000000000001100010\n" \ - "000000000000000000000000000000000000000000000000000001100011\n" \ - "000000000000000000000000000000000000000000000000000001100100\n" \ - "000000000000000000000000000000000000000000000000000001100101\n" \ - "000000000000000000000000000000000000000000000000000001100110\n" \ - "000000000000000000000000000000000000000000000000000001100111000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "00\n" \ - "010\n" \ - "011000\n" \ - "0110010\n" \ - "01100110\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "00\n" \ - "0100\n" \ - "0101\n" \ - "011000\n" \ - "01100100\n" \ - "01100101\n" \ - "01100110\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(1024), - .sparsity = 3, - .expectMincoverString = "000\n" \ - "001\n" \ - "010\n" \ - "011000\n" \ - "011001000\n" \ - "011001001\n" \ - "011001010\n" \ - "011001011\n" \ - "011001100\n" \ - "011001101\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(1024), - .sparsity = 4, - .expectMincoverString = "0000\n" \ - "0001\n" \ - "0010\n" \ - "0011\n" \ - "0100\n" \ - "0101\n" \ - "01100000\n" \ - "01100001\n" \ - "01100010\n" \ - "01100011\n" \ - "01100100\n" \ - "01100101\n" \ - "01100110\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000\n" \ - "0000000000000000000000000000000000000000000000000000010\n" \ - "0000000000000000000000000000000000000000000000000000011000\n" \ - "00000000000000000000000000000000000000000000000000000110010\n" \ - "000000000000000000000000000000000000000000000000000001100110\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 2, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000\n" \ - "00000000000000000000000000000000000000000000000000000100\n" \ - "00000000000000000000000000000000000000000000000000000101\n" \ - "0000000000000000000000000000000000000000000000000000011000\n" \ - "000000000000000000000000000000000000000000000000000001100100\n" \ - "000000000000000000000000000000000000000000000000000001100101\n" \ - "000000000000000000000000000000000000000000000000000001100110\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000\n" \ - "000000000000000000000000000000000000000000000000000001000\n" \ - "000000000000000000000000000000000000000000000000000001001\n" \ - "000000000000000000000000000000000000000000000000000001010\n" \ - "000000000000000000000000000000000000000000000000000001011\n" \ - "000000000000000000000000000000000000000000000000000001100000\n" \ - "000000000000000000000000000000000000000000000000000001100001\n" \ - "000000000000000000000000000000000000000000000000000001100010\n" \ - "000000000000000000000000000000000000000000000000000001100011\n" \ - "000000000000000000000000000000000000000000000000000001100100\n" \ - "000000000000000000000000000000000000000000000000000001100101\n" \ - "000000000000000000000000000000000000000000000000000001100110\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 4, - .expectMincoverString = "00000000000000000000000000000000000000000000000000000000\n" \ - "00000000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000000000010\n" \ - "00000000000000000000000000000000000000000000000000000011\n" \ - "00000000000000000000000000000000000000000000000000000100\n" \ - "00000000000000000000000000000000000000000000000000000101\n" \ - "000000000000000000000000000000000000000000000000000001100000\n" \ - "000000000000000000000000000000000000000000000000000001100001\n" \ - "000000000000000000000000000000000000000000000000000001100010\n" \ - "000000000000000000000000000000000000000000000000000001100011\n" \ - "000000000000000000000000000000000000000000000000000001100100\n" \ - "000000000000000000000000000000000000000000000000000001100101\n" \ - "000000000000000000000000000000000000000000000000000001100110\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "1110001101011111101010010011000110100000\n" \ - "11100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "1110001101011111101010010011000110100000\n" \ - "11100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "00000000000001110001101011111101010010011000110100000\n" \ - "000000000000011100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001101000000\n" \ - "000000000000011100011010111111010100100110001101000001\n" \ - "000000000000011100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "00000000001\n" \ - "0000000001\n" \ - "000000001\n" \ - "00000001\n" \ - "0000001\n" \ - "000001\n" \ - "00001\n" \ - "0001\n" \ - "001\n" \ - "01\n" \ - "1000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000000001000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000000000000010\n" \ - "000000000000000000000000000000000000000000000000000000000000011\n" \ - "000000000000000000000000000000000000000000000000000000000000100\n" \ - "000000000000000000000000000000000000000000000000000000000000101\n" \ - "000000000000000000000000000000000000000000000000000000000000110\n" \ - "000000000000000000000000000000000000000000000000000000000000111\n" \ - "000000000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000000000010\n" \ - "000000000000000000000000000000000000000000000000000000000011\n" \ - "000000000000000000000000000000000000000000000000000000000100\n" \ - "000000000000000000000000000000000000000000000000000000000101\n" \ - "000000000000000000000000000000000000000000000000000000000110\n" \ - "000000000000000000000000000000000000000000000000000000000111\n" \ - "000000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000000010\n" \ - "000000000000000000000000000000000000000000000000000000011\n" \ - "000000000000000000000000000000000000000000000000000000100\n" \ - "000000000000000000000000000000000000000000000000000000101\n" \ - "000000000000000000000000000000000000000000000000000000110\n" \ - "000000000000000000000000000000000000000000000000000000111\n" \ - "000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000010000000000\n" \ - "000000000000000000000000000000000000000000000000000010000000001\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "0\n" \ - "10000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "00000000000000000000000000000000000000000000000000000\n" \ - "000000000000000000000000000000000000000000000000000010000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000\n" \ - "000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000010000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000011100011010111111010100100110001101\n" \ - "00000000000001110001101011111101010010011000111\n" \ - "00000000000001110001101011111101010010011001\n" \ - "0000000000000111000110101111110101001001101\n" \ - "000000000000011100011010111111010100100111\n" \ - "000000000000011100011010111111010100101\n" \ - "00000000000001110001101011111101010011\n" \ - "000000000000011100011010111111010101\n" \ - "00000000000001110001101011111101011\n" \ - "000000000000011100011010111111011\n" \ - "00000000000001110001101011111110000\n" \ - "0000000000000111000110101111111000100\n" \ - "0000000000000111000110101111111000101000\n" \ - "00000000000001110001101011111110001010010\n" \ - "000000000000011100011010111111100010100110000\n" \ - "0000000000000111000110101111111000101001100010\n" \ - "000000000000011100011010111111100010100110001100\n" \ - "000000000000011100011010111111100010100110001101000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001101\n" \ - "000000000000011100011010111111010100100110001110\n" \ - "000000000000011100011010111111010100100110001111\n" \ - "000000000000011100011010111111010100100110010\n" \ - "000000000000011100011010111111010100100110011\n" \ - "000000000000011100011010111111010100100110100\n" \ - "000000000000011100011010111111010100100110101\n" \ - "000000000000011100011010111111010100100110110\n" \ - "000000000000011100011010111111010100100110111\n" \ - "000000000000011100011010111111010100100111\n" \ - "000000000000011100011010111111010100101\n" \ - "000000000000011100011010111111010100110\n" \ - "000000000000011100011010111111010100111\n" \ - "000000000000011100011010111111010101\n" \ - "000000000000011100011010111111010110\n" \ - "000000000000011100011010111111010111\n" \ - "000000000000011100011010111111011\n" \ - "000000000000011100011010111111100000\n" \ - "000000000000011100011010111111100001\n" \ - "000000000000011100011010111111100010000\n" \ - "000000000000011100011010111111100010001\n" \ - "000000000000011100011010111111100010010\n" \ - "000000000000011100011010111111100010011\n" \ - "000000000000011100011010111111100010100000\n" \ - "000000000000011100011010111111100010100001\n" \ - "000000000000011100011010111111100010100010\n" \ - "000000000000011100011010111111100010100011\n" \ - "000000000000011100011010111111100010100100\n" \ - "000000000000011100011010111111100010100101\n" \ - "000000000000011100011010111111100010100110000\n" \ - "000000000000011100011010111111100010100110001000\n" \ - "000000000000011100011010111111100010100110001001\n" \ - "000000000000011100011010111111100010100110001010\n" \ - "000000000000011100011010111111100010100110001011\n" \ - "000000000000011100011010111111100010100110001100\n" \ - "000000000000011100011010111111100010100110001101000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000001\n" \ - "0000000000000000000000000000000001\n" \ - "0000000000000000000000000000000010\n" \ - "00000000000000000000000000000000110\n" \ - "00000000000000000000000000000000111000000000000000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000\n" \ - "0000000000000000000000000000000010\n" \ - "00000000000000000000000000000000110\n" \ - "000000000000000000000000000000001110000000000000000000000000000\n" -}, -{ - .lowerBound = 0, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000\n" \ - "000000000000000000000000000000001000\n" \ - "000000000000000000000000000000001001\n" \ - "000000000000000000000000000000001010\n" \ - "000000000000000000000000000000001011\n" \ - "000000000000000000000000000000001100\n" \ - "000000000000000000000000000000001101\n" \ - "000000000000000000000000000000001110000000000000000000000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001101000001100110111\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001101000001100110111\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000011100011010111111010100100110001101000001100110111\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001101000001100110111\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "01100111000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000001100111000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000001100111000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "01100110111\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000001100110111\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 823, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000001100110111\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001101000001100110111\n" \ - "11100011010111111010100100110001101000001100111\n" \ - "11100011010111111010100100110001101000001101\n" \ - "1110001101011111101010010011000110100000111\n" \ - "11100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001101000001100110111\n" \ - "111000110101111110101001001100011010000011001110\n" \ - "111000110101111110101001001100011010000011001111\n" \ - "11100011010111111010100100110001101000001101\n" \ - "11100011010111111010100100110001101000001110\n" \ - "11100011010111111010100100110001101000001111\n" \ - "11100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000011100011010111111010100100110001101000001100110111\n" \ - "000000000000011100011010111111010100100110001101000001100111\n" \ - "000000000000011100011010111111010100100110001101000001101\n" \ - "00000000000001110001101011111101010010011000110100000111\n" \ - "000000000000011100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001101000001100110111\n" \ - "000000000000011100011010111111010100100110001101000001100111\n" \ - "000000000000011100011010111111010100100110001101000001101\n" \ - "000000000000011100011010111111010100100110001101000001110\n" \ - "000000000000011100011010111111010100100110001101000001111\n" \ - "000000000000011100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "01100111\n" \ - "01101\n" \ - "0111\n" \ - "1000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "01100111\n" \ - "011010\n" \ - "011011\n" \ - "0111\n" \ - "1000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000001100111\n" \ - "000000000000000000000000000000000000000000000000000001101\n" \ - "00000000000000000000000000000000000000000000000000000111\n" \ - "00000000000000000000000000000000000000000000000000001000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 2, - .expectMincoverString = "000000000000000000000000000000000000000000000000000001100111\n" \ - "0000000000000000000000000000000000000000000000000000011010\n" \ - "0000000000000000000000000000000000000000000000000000011011\n" \ - "00000000000000000000000000000000000000000000000000000111\n" \ - "00000000000000000000000000000000000000000000000000001000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000001100111\n" \ - "000000000000000000000000000000000000000000000000000001101\n" \ - "000000000000000000000000000000000000000000000000000001110\n" \ - "000000000000000000000000000000000000000000000000000001111\n" \ - "000000000000000000000000000000000000000000000000000010000000000\n" \ - "000000000000000000000000000000000000000000000000000010000000001\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "01100110111\n" \ - "01100111\n" \ - "01101\n" \ - "0111\n" \ - "10000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000001100110111\n" \ - "000000000000000000000000000000000000000000000000000001100111\n" \ - "000000000000000000000000000000000000000000000000000001101\n" \ - "00000000000000000000000000000000000000000000000000000111\n" \ - "000000000000000000000000000000000000000000000000000010000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000001100110111\n" \ - "000000000000000000000000000000000000000000000000000001100111\n" \ - "000000000000000000000000000000000000000000000000000001101\n" \ - "000000000000000000000000000000000000000000000000000001110\n" \ - "000000000000000000000000000000000000000000000000000001111\n" \ - "000000000000000000000000000000000000000000000000000010000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000011100011010111111010100100110001101000001100110111\n" \ - "000000000000011100011010111111010100100110001101000001100111\n" \ - "000000000000011100011010111111010100100110001101000001101\n" \ - "00000000000001110001101011111101010010011000110100000111\n" \ - "00000000000001110001101011111101010010011000110100001\n" \ - "0000000000000111000110101111110101001001100011010001\n" \ - "000000000000011100011010111111010100100110001101001\n" \ - "00000000000001110001101011111101010010011000110101\n" \ - "0000000000000111000110101111110101001001100011011\n" \ - "00000000000001110001101011111101010010011000111\n" \ - "00000000000001110001101011111101010010011001\n" \ - "0000000000000111000110101111110101001001101\n" \ - "000000000000011100011010111111010100100111\n" \ - "000000000000011100011010111111010100101\n" \ - "00000000000001110001101011111101010011\n" \ - "000000000000011100011010111111010101\n" \ - "00000000000001110001101011111101011\n" \ - "000000000000011100011010111111011\n" \ - "00000000000001110001101011111110000\n" \ - "0000000000000111000110101111111000100\n" \ - "0000000000000111000110101111111000101000\n" \ - "00000000000001110001101011111110001010010\n" \ - "000000000000011100011010111111100010100110000\n" \ - "0000000000000111000110101111111000101001100010\n" \ - "000000000000011100011010111111100010100110001100\n" \ - "000000000000011100011010111111100010100110001101000000000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000001100111\n" \ - "000000000000000000000000000000000000000000000000000001101\n" \ - "00000000000000000000000000000000000000000000000000000111\n" \ - "00000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000001\n" \ - "0000000000000000000000000000000001\n" \ - "0000000000000000000000000000000010\n" \ - "00000000000000000000000000000000110\n" \ - "00000000000000000000000000000000111000000000000000000000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 2, - .expectMincoverString = "000000000000000000000000000000000000000000000000000001100111\n" \ - "0000000000000000000000000000000000000000000000000000011010\n" \ - "0000000000000000000000000000000000000000000000000000011011\n" \ - "00000000000000000000000000000000000000000000000000000111\n" \ - "000000000000000000000000000000000000000000000000000010\n" \ - "000000000000000000000000000000000000000000000000000011\n" \ - "0000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000010\n" \ - "0000000000000000000000000000000000000000000000000011\n" \ - "00000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000010\n" \ - "00000000000000000000000000000000000000000000000011\n" \ - "000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000010\n" \ - "000000000000000000000000000000000000000000000011\n" \ - "0000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000010\n" \ - "0000000000000000000000000000000000000000000011\n" \ - "00000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000010\n" \ - "00000000000000000000000000000000000000000011\n" \ - "000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000010\n" \ - "000000000000000000000000000000000000000011\n" \ - "0000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000010\n" \ - "0000000000000000000000000000000000000011\n" \ - "00000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000010\n" \ - "00000000000000000000000000000000000011\n" \ - "000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000010\n" \ - "000000000000000000000000000000000011\n" \ - "0000000000000000000000000000000001\n" \ - "0000000000000000000000000000000010\n" \ - "000000000000000000000000000000001100\n" \ - "000000000000000000000000000000001101\n" \ - "00000000000000000000000000000000111000000000000000000000000000\n" -}, -{ - .lowerBound = 823, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000001100110111\n" \ - "000000000000000000000000000000000000000000000000000001100111\n" \ - "000000000000000000000000000000000000000000000000000001101\n" \ - "00000000000000000000000000000000000000000000000000000111\n" \ - "00000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000001\n" \ - "0000000000000000000000000000000001\n" \ - "0000000000000000000000000000000010\n" \ - "00000000000000000000000000000000110\n" \ - "000000000000000000000000000000001110000000000000000000000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "11100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(1024), - .sparsity = 2, - .expectMincoverString = "11100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000011100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001101000010000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "10000000001\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000010000000001\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000010000000001\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(1024), - .sparsity = 1, - .expectMincoverString = "10000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000010000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000010000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(1024), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1024, - .includeUpperBound = true, - .min = OPT_I64_C(1024), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000000000000000000000000000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "00000000000001110001101011111101010010011000110100001\n" \ - "0000000000000111000110101111110101001001100011010001\n" \ - "000000000000011100011010111111010100100110001101001\n" \ - "00000000000001110001101011111101010010011000110101\n" \ - "0000000000000111000110101111110101001001100011011\n" \ - "00000000000001110001101011111101010010011000111\n" \ - "00000000000001110001101011111101010010011001\n" \ - "0000000000000111000110101111110101001001101\n" \ - "000000000000011100011010111111010100100111\n" \ - "000000000000011100011010111111010100101\n" \ - "00000000000001110001101011111101010011\n" \ - "000000000000011100011010111111010101\n" \ - "00000000000001110001101011111101011\n" \ - "000000000000011100011010111111011\n" \ - "00000000000001110001101011111110000\n" \ - "0000000000000111000110101111111000100\n" \ - "0000000000000111000110101111111000101000\n" \ - "00000000000001110001101011111110001010010\n" \ - "000000000000011100011010111111100010100110000\n" \ - "0000000000000111000110101111111000101001100010\n" \ - "000000000000011100011010111111100010100110001100\n" \ - "000000000000011100011010111111100010100110001101000000000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111010100100110001101000010\n" \ - "000000000000011100011010111111010100100110001101000011\n" \ - "000000000000011100011010111111010100100110001101000100\n" \ - "000000000000011100011010111111010100100110001101000101\n" \ - "000000000000011100011010111111010100100110001101000110\n" \ - "000000000000011100011010111111010100100110001101000111\n" \ - "000000000000011100011010111111010100100110001101001\n" \ - "000000000000011100011010111111010100100110001101010\n" \ - "000000000000011100011010111111010100100110001101011\n" \ - "000000000000011100011010111111010100100110001101100\n" \ - "000000000000011100011010111111010100100110001101101\n" \ - "000000000000011100011010111111010100100110001101110\n" \ - "000000000000011100011010111111010100100110001101111\n" \ - "000000000000011100011010111111010100100110001110\n" \ - "000000000000011100011010111111010100100110001111\n" \ - "000000000000011100011010111111010100100110010\n" \ - "000000000000011100011010111111010100100110011\n" \ - "000000000000011100011010111111010100100110100\n" \ - "000000000000011100011010111111010100100110101\n" \ - "000000000000011100011010111111010100100110110\n" \ - "000000000000011100011010111111010100100110111\n" \ - "000000000000011100011010111111010100100111\n" \ - "000000000000011100011010111111010100101\n" \ - "000000000000011100011010111111010100110\n" \ - "000000000000011100011010111111010100111\n" \ - "000000000000011100011010111111010101\n" \ - "000000000000011100011010111111010110\n" \ - "000000000000011100011010111111010111\n" \ - "000000000000011100011010111111011\n" \ - "000000000000011100011010111111100000\n" \ - "000000000000011100011010111111100001\n" \ - "000000000000011100011010111111100010000\n" \ - "000000000000011100011010111111100010001\n" \ - "000000000000011100011010111111100010010\n" \ - "000000000000011100011010111111100010011\n" \ - "000000000000011100011010111111100010100000\n" \ - "000000000000011100011010111111100010100001\n" \ - "000000000000011100011010111111100010100010\n" \ - "000000000000011100011010111111100010100011\n" \ - "000000000000011100011010111111100010100100\n" \ - "000000000000011100011010111111100010100101\n" \ - "000000000000011100011010111111100010100110000\n" \ - "000000000000011100011010111111100010100110001000\n" \ - "000000000000011100011010111111100010100110001001\n" \ - "000000000000011100011010111111100010100110001010\n" \ - "000000000000011100011010111111100010100110001011\n" \ - "000000000000011100011010111111100010100110001100\n" \ - "000000000000011100011010111111100010100110001101000000000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000000000000000000000010000000001\n" \ - "00000000000000000000000000000000000000000000000000001000000001\n" \ - "0000000000000000000000000000000000000000000000000000100000001\n" \ - "000000000000000000000000000000000000000000000000000010000001\n" \ - "00000000000000000000000000000000000000000000000000001000001\n" \ - "0000000000000000000000000000000000000000000000000000100001\n" \ - "000000000000000000000000000000000000000000000000000010001\n" \ - "00000000000000000000000000000000000000000000000000001001\n" \ - "0000000000000000000000000000000000000000000000000000101\n" \ - "000000000000000000000000000000000000000000000000000011\n" \ - "0000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000001\n" \ - "0000000000000000000000000000000001\n" \ - "0000000000000000000000000000000010\n" \ - "00000000000000000000000000000000110\n" \ - "00000000000000000000000000000000111000000000000000000000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "00000000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000000001\n" \ - "0000000000000000000000000000000000001\n" \ - "000000000000000000000000000000000001\n" \ - "00000000000000000000000000000000001\n" \ - "0000000000000000000000000000000001\n" \ - "0000000000000000000000000000000010\n" \ - "00000000000000000000000000000000110\n" \ - "000000000000000000000000000000001110000000000000000000000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(1024), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000000\n" \ - "0000000000000000000000000000000010\n" \ - "000000000000000000000000000000001100\n" \ - "0000000000000000000000000000000011010\n" \ - "00000000000000000000000000000000110110\n" \ - "000000000000000000000000000000001101110\n" \ - "0000000000000000000000000000000011011110\n" \ - "00000000000000000000000000000000110111110\n" \ - "000000000000000000000000000000001101111110\n" \ - "0000000000000000000000000000000011011111110\n" \ - "00000000000000000000000000000000110111111110\n" \ - "000000000000000000000000000000001101111111110\n" \ - "0000000000000000000000000000000011011111111110\n" \ - "00000000000000000000000000000000110111111111110\n" \ - "000000000000000000000000000000001101111111111110\n" \ - "0000000000000000000000000000000011011111111111110\n" \ - "00000000000000000000000000000000110111111111111110\n" \ - "000000000000000000000000000000001101111111111111110\n" \ - "0000000000000000000000000000000011011111111111111110\n" \ - "00000000000000000000000000000000110111111111111111110\n" \ - "000000000000000000000000000000001101111111111111111110000000000\n" -}, -{ - .lowerBound = 1024, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(1024), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000000\n" \ - "000000000000000000000000000000001000\n" \ - "000000000000000000000000000000001001\n" \ - "000000000000000000000000000000001010\n" \ - "000000000000000000000000000000001011\n" \ - "000000000000000000000000000000001100\n" \ - "000000000000000000000000000000001101000\n" \ - "000000000000000000000000000000001101001\n" \ - "000000000000000000000000000000001101010\n" \ - "000000000000000000000000000000001101011\n" \ - "000000000000000000000000000000001101100\n" \ - "000000000000000000000000000000001101101\n" \ - "000000000000000000000000000000001101110\n" \ - "000000000000000000000000000000001101111000\n" \ - "000000000000000000000000000000001101111001\n" \ - "000000000000000000000000000000001101111010\n" \ - "000000000000000000000000000000001101111011\n" \ - "000000000000000000000000000000001101111100\n" \ - "000000000000000000000000000000001101111101\n" \ - "000000000000000000000000000000001101111110\n" \ - "000000000000000000000000000000001101111111000\n" \ - "000000000000000000000000000000001101111111001\n" \ - "000000000000000000000000000000001101111111010\n" \ - "000000000000000000000000000000001101111111011\n" \ - "000000000000000000000000000000001101111111100\n" \ - "000000000000000000000000000000001101111111101\n" \ - "000000000000000000000000000000001101111111110\n" \ - "000000000000000000000000000000001101111111111000\n" \ - "000000000000000000000000000000001101111111111001\n" \ - "000000000000000000000000000000001101111111111010\n" \ - "000000000000000000000000000000001101111111111011\n" \ - "000000000000000000000000000000001101111111111100\n" \ - "000000000000000000000000000000001101111111111101\n" \ - "000000000000000000000000000000001101111111111110\n" \ - "000000000000000000000000000000001101111111111111000\n" \ - "000000000000000000000000000000001101111111111111001\n" \ - "000000000000000000000000000000001101111111111111010\n" \ - "000000000000000000000000000000001101111111111111011\n" \ - "000000000000000000000000000000001101111111111111100\n" \ - "000000000000000000000000000000001101111111111111101\n" \ - "000000000000000000000000000000001101111111111111110\n" \ - "000000000000000000000000000000001101111111111111111000\n" \ - "000000000000000000000000000000001101111111111111111001\n" \ - "000000000000000000000000000000001101111111111111111010\n" \ - "000000000000000000000000000000001101111111111111111011\n" \ - "000000000000000000000000000000001101111111111111111100\n" \ - "000000000000000000000000000000001101111111111111111101\n" \ - "000000000000000000000000000000001101111111111111111110000000000\n" -}, -{ - .lowerBound = 1879048192, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000011100011010111111100010100110001101000000000000000\n" -}, -{ - .lowerBound = 1879048192, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1000000000000000), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000011100011010111111100010100110001101000000000000000\n" -}, -{ - .lowerBound = 1879048192, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000001110000000000000000000000000001\n" -}, -{ - .lowerBound = 1879048192, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(-1), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000001110000000000000000000000000001\n" -}, -{ - .lowerBound = 1879048192, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000001110000000000000000000000000000\n" -}, -{ - .lowerBound = 1879048192, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(0), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000001110000000000000000000000000000\n" -}, -{ - .lowerBound = 1879048192, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(1024), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 1, - .expectMincoverString = "000000000000000000000000000000001101111111111111111110000000000\n" -}, -{ - .lowerBound = 1879048192, - .includeLowerBound = true, - .upperBound = 1879048192, - .includeUpperBound = true, - .min = OPT_I64_C(1024), - .max = OPT_I64_C(8070450532247928832), - .sparsity = 3, - .expectMincoverString = "000000000000000000000000000000001101111111111111111110000000000\n" +// This code is GENERATED! Do not edit! +// clang-format off +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111110011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111110011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111110011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111110011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111110011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111110011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111110011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -100, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111110011100", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101", + "11100011010111111010100100110001100111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "1110001101011111101010010011000110011111111010", + "1110001101011111101010010011000110011111111011", + "11100011010111111010100100110001100111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101", + "111000110101111110101001001100011001111111110", + "111000110101111110101001001100011001111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101000", + "111000110101111110101001001100011001111111101001", + "111000110101111110101001001100011001111111101010", + "111000110101111110101001001100011001111111101011", + "111000110101111110101001001100011001111111101100", + "111000110101111110101001001100011001111111101101", + "111000110101111110101001001100011001111111101110", + "111000110101111110101001001100011001111111101111", + "11100011010111111010100100110001100111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101", + "11100011010111111010100100110001100111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "1110001101011111101010010011000110011111111010", + "1110001101011111101010010011000110011111111011", + "11100011010111111010100100110001100111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101", + "111000110101111110101001001100011001111111110", + "111000110101111110101001001100011001111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101000", + "111000110101111110101001001100011001111111101001", + "111000110101111110101001001100011001111111101010", + "111000110101111110101001001100011001111111101011", + "111000110101111110101001001100011001111111101100", + "111000110101111110101001001100011001111111101101", + "111000110101111110101001001100011001111111101110", + "111000110101111110101001001100011001111111101111", + "11100011010111111010100100110001100111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101", + "11100011010111111010100100110001100111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "1110001101011111101010010011000110011111111010", + "1110001101011111101010010011000110011111111011", + "11100011010111111010100100110001100111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101", + "111000110101111110101001001100011001111111110", + "111000110101111110101001001100011001111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101000", + "111000110101111110101001001100011001111111101001", + "111000110101111110101001001100011001111111101010", + "111000110101111110101001001100011001111111101011", + "111000110101111110101001001100011001111111101100", + "111000110101111110101001001100011001111111101101", + "111000110101111110101001001100011001111111101110", + "111000110101111110101001001100011001111111101111", + "11100011010111111010100100110001100111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "0000000000000111000110101111110101001001100011001111111100111", + "0000000000000111000110101111110101001001100011001111111101", + "000000000000011100011010111111010100100110001100111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "00000000000001110001101011111101010010011000110011111111001110", + "00000000000001110001101011111101010010011000110011111111001111", + "0000000000000111000110101111110101001001100011001111111101", + "0000000000000111000110101111110101001001100011001111111110", + "0000000000000111000110101111110101001001100011001111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111110011100", + "000000000000011100011010111111010100100110001100111111110011101", + "000000000000011100011010111111010100100110001100111111110011110", + "000000000000011100011010111111010100100110001100111111110011111", + "000000000000011100011010111111010100100110001100111111110100", + "000000000000011100011010111111010100100110001100111111110101", + "000000000000011100011010111111010100100110001100111111110110", + "000000000000011100011010111111010100100110001100111111110111", + "000000000000011100011010111111010100100110001100111111111", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101", + "11100011010111111010100100110001100111111111", + "11100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "1110001101011111101010010011000110011111111010", + "1110001101011111101010010011000110011111111011", + "11100011010111111010100100110001100111111111", + "11100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101", + "11100011010111111010100100110001100111111111", + "11100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "1110001101011111101010010011000110011111111010", + "1110001101011111101010010011000110011111111011", + "11100011010111111010100100110001100111111111", + "11100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "0000000000000111000110101111110101001001100011001111111100111", + "0000000000000111000110101111110101001001100011001111111101", + "000000000000011100011010111111010100100110001100111111111", + "000000000000011100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111110011100", + "000000000000011100011010111111010100100110001100111111110011101", + "000000000000011100011010111111010100100110001100111111110011110", + "000000000000011100011010111111010100100110001100111111110011111", + "000000000000011100011010111111010100100110001100111111110100", + "000000000000011100011010111111010100100110001100111111110101", + "000000000000011100011010111111010100100110001100111111110110", + "000000000000011100011010111111010100100110001100111111110111", + "000000000000011100011010111111010100100110001100111111111", + "000000000000011100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101", + "11100011010111111010100100110001100111111111", + "11100011010111111010100100110001101000000", + "111000110101111110101001001100011010000010", + "111000110101111110101001001100011010000011000", + "1110001101011111101010010011000110100000110010", + "11100011010111111010100100110001101000001100110", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "1110001101011111101010010011000110011111111010", + "1110001101011111101010010011000110011111111011", + "11100011010111111010100100110001100111111111", + "111000110101111110101001001100011010000000", + "111000110101111110101001001100011010000001", + "111000110101111110101001001100011010000010", + "1110001101011111101010010011000110100000110000", + "1110001101011111101010010011000110100000110001", + "1110001101011111101010010011000110100000110010", + "111000110101111110101001001100011010000011001100", + "111000110101111110101001001100011010000011001101", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101", + "111000110101111110101001001100011001111111110", + "111000110101111110101001001100011001111111111", + "111000110101111110101001001100011010000000", + "111000110101111110101001001100011010000001", + "111000110101111110101001001100011010000010", + "111000110101111110101001001100011010000011000", + "111000110101111110101001001100011010000011001000", + "111000110101111110101001001100011010000011001001", + "111000110101111110101001001100011010000011001010", + "111000110101111110101001001100011010000011001011", + "111000110101111110101001001100011010000011001100", + "111000110101111110101001001100011010000011001101", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101000", + "111000110101111110101001001100011001111111101001", + "111000110101111110101001001100011001111111101010", + "111000110101111110101001001100011001111111101011", + "111000110101111110101001001100011001111111101100", + "111000110101111110101001001100011001111111101101", + "111000110101111110101001001100011001111111101110", + "111000110101111110101001001100011001111111101111", + "11100011010111111010100100110001100111111111", + "11100011010111111010100100110001101000000000", + "11100011010111111010100100110001101000000001", + "11100011010111111010100100110001101000000010", + "11100011010111111010100100110001101000000011", + "11100011010111111010100100110001101000000100", + "11100011010111111010100100110001101000000101", + "11100011010111111010100100110001101000000110", + "11100011010111111010100100110001101000000111", + "11100011010111111010100100110001101000001000", + "11100011010111111010100100110001101000001001", + "11100011010111111010100100110001101000001010", + "11100011010111111010100100110001101000001011", + "111000110101111110101001001100011010000011000000", + "111000110101111110101001001100011010000011000001", + "111000110101111110101001001100011010000011000010", + "111000110101111110101001001100011010000011000011", + "111000110101111110101001001100011010000011000100", + "111000110101111110101001001100011010000011000101", + "111000110101111110101001001100011010000011000110", + "111000110101111110101001001100011010000011000111", + "111000110101111110101001001100011010000011001000", + "111000110101111110101001001100011010000011001001", + "111000110101111110101001001100011010000011001010", + "111000110101111110101001001100011010000011001011", + "111000110101111110101001001100011010000011001100", + "111000110101111110101001001100011010000011001101", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "0000000000000111000110101111110101001001100011001111111100111", + "0000000000000111000110101111110101001001100011001111111101", + "000000000000011100011010111111010100100110001100111111111", + "000000000000011100011010111111010100100110001101000000", + "0000000000000111000110101111110101001001100011010000010", + "0000000000000111000110101111110101001001100011010000011000", + "00000000000001110001101011111101010010011000110100000110010", + "000000000000011100011010111111010100100110001101000001100110", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "00000000000001110001101011111101010010011000110011111111001110", + "00000000000001110001101011111101010010011000110011111111001111", + "0000000000000111000110101111110101001001100011001111111101", + "0000000000000111000110101111110101001001100011001111111110", + "0000000000000111000110101111110101001001100011001111111111", + "000000000000011100011010111111010100100110001101000000", + "00000000000001110001101011111101010010011000110100000100", + "00000000000001110001101011111101010010011000110100000101", + "0000000000000111000110101111110101001001100011010000011000", + "000000000000011100011010111111010100100110001101000001100100", + "000000000000011100011010111111010100100110001101000001100101", + "000000000000011100011010111111010100100110001101000001100110", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111110011100", + "000000000000011100011010111111010100100110001100111111110011101", + "000000000000011100011010111111010100100110001100111111110011110", + "000000000000011100011010111111010100100110001100111111110011111", + "000000000000011100011010111111010100100110001100111111110100", + "000000000000011100011010111111010100100110001100111111110101", + "000000000000011100011010111111010100100110001100111111110110", + "000000000000011100011010111111010100100110001100111111110111", + "000000000000011100011010111111010100100110001100111111111", + "000000000000011100011010111111010100100110001101000000", + "000000000000011100011010111111010100100110001101000001000", + "000000000000011100011010111111010100100110001101000001001", + "000000000000011100011010111111010100100110001101000001010", + "000000000000011100011010111111010100100110001101000001011", + "000000000000011100011010111111010100100110001101000001100000", + "000000000000011100011010111111010100100110001101000001100001", + "000000000000011100011010111111010100100110001101000001100010", + "000000000000011100011010111111010100100110001101000001100011", + "000000000000011100011010111111010100100110001101000001100100", + "000000000000011100011010111111010100100110001101000001100101", + "000000000000011100011010111111010100100110001101000001100110", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "111000110101111110101001001100011001111111101", + "11100011010111111010100100110001100111111111", + "1110001101011111101010010011000110100000", + "11100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "111000110101111110101001001100011001111111100111", + "1110001101011111101010010011000110011111111010", + "1110001101011111101010010011000110011111111011", + "11100011010111111010100100110001100111111111", + "1110001101011111101010010011000110100000", + "11100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "0000000000000111000110101111110101001001100011001111111100111", + "0000000000000111000110101111110101001001100011001111111101", + "000000000000011100011010111111010100100110001100111111111", + "00000000000001110001101011111101010010011000110100000", + "000000000000011100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111110011100", + "000000000000011100011010111111010100100110001100111111110011101", + "000000000000011100011010111111010100100110001100111111110011110", + "000000000000011100011010111111010100100110001100111111110011111", + "000000000000011100011010111111010100100110001100111111110100", + "000000000000011100011010111111010100100110001100111111110101", + "000000000000011100011010111111010100100110001100111111110110", + "000000000000011100011010111111010100100110001100111111110111", + "000000000000011100011010111111010100100110001100111111111", + "000000000000011100011010111111010100100110001101000000", + "000000000000011100011010111111010100100110001101000001", + "000000000000011100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "0000000000000111000110101111110101001001100011001111111100111", + "0000000000000111000110101111110101001001100011001111111101", + "000000000000011100011010111111010100100110001100111111111", + "000000000000011100011010111111010100100110001101", + "00000000000001110001101011111101010010011000111", + "00000000000001110001101011111101010010011001", + "0000000000000111000110101111110101001001101", + "000000000000011100011010111111010100100111", + "000000000000011100011010111111010100101", + "00000000000001110001101011111101010011", + "000000000000011100011010111111010101", + "00000000000001110001101011111101011", + "000000000000011100011010111111011", + "00000000000001110001101011111110000", + "0000000000000111000110101111111000100", + "0000000000000111000110101111111000101000", + "00000000000001110001101011111110001010010", + "000000000000011100011010111111100010100110000", + "0000000000000111000110101111111000101001100010", + "000000000000011100011010111111100010100110001100", + "000000000000011100011010111111100010100110001101000000000000000", + }, +}, +{ + .lowerBound = -100, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111110011100", + "000000000000011100011010111111010100100110001100111111110011101", + "000000000000011100011010111111010100100110001100111111110011110", + "000000000000011100011010111111010100100110001100111111110011111", + "000000000000011100011010111111010100100110001100111111110100", + "000000000000011100011010111111010100100110001100111111110101", + "000000000000011100011010111111010100100110001100111111110110", + "000000000000011100011010111111010100100110001100111111110111", + "000000000000011100011010111111010100100110001100111111111", + "000000000000011100011010111111010100100110001101", + "000000000000011100011010111111010100100110001110", + "000000000000011100011010111111010100100110001111", + "000000000000011100011010111111010100100110010", + "000000000000011100011010111111010100100110011", + "000000000000011100011010111111010100100110100", + "000000000000011100011010111111010100100110101", + "000000000000011100011010111111010100100110110", + "000000000000011100011010111111010100100110111", + "000000000000011100011010111111010100100111", + "000000000000011100011010111111010100101", + "000000000000011100011010111111010100110", + "000000000000011100011010111111010100111", + "000000000000011100011010111111010101", + "000000000000011100011010111111010110", + "000000000000011100011010111111010111", + "000000000000011100011010111111011", + "000000000000011100011010111111100000", + "000000000000011100011010111111100001", + "000000000000011100011010111111100010000", + "000000000000011100011010111111100010001", + "000000000000011100011010111111100010010", + "000000000000011100011010111111100010011", + "000000000000011100011010111111100010100000", + "000000000000011100011010111111100010100001", + "000000000000011100011010111111100010100010", + "000000000000011100011010111111100010100011", + "000000000000011100011010111111100010100100", + "000000000000011100011010111111100010100101", + "000000000000011100011010111111100010100110000", + "000000000000011100011010111111100010100110001000", + "000000000000011100011010111111100010100110001001", + "000000000000011100011010111111100010100110001010", + "000000000000011100011010111111100010100110001011", + "000000000000011100011010111111100010100110001100", + "000000000000011100011010111111100010100110001101000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111111111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = -1 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111111111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111111111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111111111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111111111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111111111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111111111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111111111111", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "0", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "00000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = -1, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111111111111", + "11100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111111111111", + "11100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111111111111", + "11100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111111111111", + "11100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111111111111", + "000000000000011100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111111111111", + "000000000000011100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "root", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "root", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "root", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "root", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "0000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "0000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "00000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "00000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000000000000", + "000000000000000000000000000000000000000000000000000000000000001", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111111111111", + "11100011010111111010100100110001101000000", + "111000110101111110101001001100011010000010", + "111000110101111110101001001100011010000011000", + "1110001101011111101010010011000110100000110010", + "11100011010111111010100100110001101000001100110", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111111111111", + "111000110101111110101001001100011010000000", + "111000110101111110101001001100011010000001", + "111000110101111110101001001100011010000010", + "1110001101011111101010010011000110100000110000", + "1110001101011111101010010011000110100000110001", + "1110001101011111101010010011000110100000110010", + "111000110101111110101001001100011010000011001100", + "111000110101111110101001001100011010000011001101", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111111111111", + "000000000000011100011010111111010100100110001101000000", + "0000000000000111000110101111110101001001100011010000010", + "0000000000000111000110101111110101001001100011010000011000", + "00000000000001110001101011111101010010011000110100000110010", + "000000000000011100011010111111010100100110001101000001100110", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111111111111", + "000000000000011100011010111111010100100110001101000000", + "000000000000011100011010111111010100100110001101000001000", + "000000000000011100011010111111010100100110001101000001001", + "000000000000011100011010111111010100100110001101000001010", + "000000000000011100011010111111010100100110001101000001011", + "000000000000011100011010111111010100100110001101000001100000", + "000000000000011100011010111111010100100110001101000001100001", + "000000000000011100011010111111010100100110001101000001100010", + "000000000000011100011010111111010100100110001101000001100011", + "000000000000011100011010111111010100100110001101000001100100", + "000000000000011100011010111111010100100110001101000001100101", + "000000000000011100011010111111010100100110001101000001100110", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "00", + "010", + "011000", + "0110010", + "01100110", + "01100111000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000", + "0000000000000000000000000000000000000000000000000000010", + "0000000000000000000000000000000000000000000000000000011000", + "00000000000000000000000000000000000000000000000000000110010", + "000000000000000000000000000000000000000000000000000001100110", + "000000000000000000000000000000000000000000000000000001100111000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000", + "000000000000000000000000000000000000000000000000000001000", + "000000000000000000000000000000000000000000000000000001001", + "000000000000000000000000000000000000000000000000000001010", + "000000000000000000000000000000000000000000000000000001011", + "000000000000000000000000000000000000000000000000000001100000", + "000000000000000000000000000000000000000000000000000001100001", + "000000000000000000000000000000000000000000000000000001100010", + "000000000000000000000000000000000000000000000000000001100011", + "000000000000000000000000000000000000000000000000000001100100", + "000000000000000000000000000000000000000000000000000001100101", + "000000000000000000000000000000000000000000000000000001100110", + "000000000000000000000000000000000000000000000000000001100111000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111111111111", + "1110001101011111101010010011000110100000", + "11100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001100111111111111111", + "1110001101011111101010010011000110100000", + "11100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111111111111", + "00000000000001110001101011111101010010011000110100000", + "000000000000011100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111111111111", + "000000000000011100011010111111010100100110001101000000", + "000000000000011100011010111111010100100110001101000001", + "000000000000011100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "0", + "1000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "00", + "01", + "1000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "00000000000000000000000000000000000000000000000000000", + "00000000000000000000000000000000000000000000000000001000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000", + "000000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000000001000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000", + "000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000010000000000", + "000000000000000000000000000000000000000000000000000010000000001", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111111111111", + "000000000000011100011010111111010100100110001101", + "00000000000001110001101011111101010010011000111", + "00000000000001110001101011111101010010011001", + "0000000000000111000110101111110101001001101", + "000000000000011100011010111111010100100111", + "000000000000011100011010111111010100101", + "00000000000001110001101011111101010011", + "000000000000011100011010111111010101", + "00000000000001110001101011111101011", + "000000000000011100011010111111011", + "00000000000001110001101011111110000", + "0000000000000111000110101111111000100", + "0000000000000111000110101111111000101000", + "00000000000001110001101011111110001010010", + "000000000000011100011010111111100010100110000", + "0000000000000111000110101111111000101001100010", + "000000000000011100011010111111100010100110001100", + "000000000000011100011010111111100010100110001101000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001100111111111111111", + "000000000000011100011010111111010100100110001101", + "000000000000011100011010111111010100100110001110", + "000000000000011100011010111111010100100110001111", + "000000000000011100011010111111010100100110010", + "000000000000011100011010111111010100100110011", + "000000000000011100011010111111010100100110100", + "000000000000011100011010111111010100100110101", + "000000000000011100011010111111010100100110110", + "000000000000011100011010111111010100100110111", + "000000000000011100011010111111010100100111", + "000000000000011100011010111111010100101", + "000000000000011100011010111111010100110", + "000000000000011100011010111111010100111", + "000000000000011100011010111111010101", + "000000000000011100011010111111010110", + "000000000000011100011010111111010111", + "000000000000011100011010111111011", + "000000000000011100011010111111100000", + "000000000000011100011010111111100001", + "000000000000011100011010111111100010000", + "000000000000011100011010111111100010001", + "000000000000011100011010111111100010010", + "000000000000011100011010111111100010011", + "000000000000011100011010111111100010100000", + "000000000000011100011010111111100010100001", + "000000000000011100011010111111100010100010", + "000000000000011100011010111111100010100011", + "000000000000011100011010111111100010100100", + "000000000000011100011010111111100010100101", + "000000000000011100011010111111100010100110000", + "000000000000011100011010111111100010100110001000", + "000000000000011100011010111111100010100110001001", + "000000000000011100011010111111100010100110001010", + "000000000000011100011010111111100010100110001011", + "000000000000011100011010111111100010100110001100", + "000000000000011100011010111111100010100110001101000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000", + "0000000000000000000000000000000010", + "00000000000000000000000000000000110", + "00000000000000000000000000000000111000000000000000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "0000000000000000000000000000000000", + "0000000000000000000000000000000001", + "0000000000000000000000000000000010", + "000000000000000000000000000000001100", + "000000000000000000000000000000001101", + "00000000000000000000000000000000111000000000000000000000000000", + }, +}, +{ + .lowerBound = -1, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000", + "000000000000000000000000000000001000", + "000000000000000000000000000000001001", + "000000000000000000000000000000001010", + "000000000000000000000000000000001011", + "000000000000000000000000000000001100", + "000000000000000000000000000000001101", + "000000000000000000000000000000001110000000000000000000000000000", + "000000000000000000000000000000001110000000000000000000000000001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "11100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "11100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 0 }, + .expectMincoverStrings = { + "1", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "00000000001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000000000001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000000000001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "00000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 0, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001101000000", + "111000110101111110101001001100011010000010", + "111000110101111110101001001100011010000011000", + "1110001101011111101010010011000110100000110010", + "11100011010111111010100100110001101000001100110", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "111000110101111110101001001100011010000000", + "111000110101111110101001001100011010000001", + "111000110101111110101001001100011010000010", + "1110001101011111101010010011000110100000110000", + "1110001101011111101010010011000110100000110001", + "1110001101011111101010010011000110100000110010", + "111000110101111110101001001100011010000011001100", + "111000110101111110101001001100011010000011001101", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "111000110101111110101001001100011010000000", + "111000110101111110101001001100011010000001", + "111000110101111110101001001100011010000010", + "111000110101111110101001001100011010000011000", + "111000110101111110101001001100011010000011001000", + "111000110101111110101001001100011010000011001001", + "111000110101111110101001001100011010000011001010", + "111000110101111110101001001100011010000011001011", + "111000110101111110101001001100011010000011001100", + "111000110101111110101001001100011010000011001101", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001101000000000", + "11100011010111111010100100110001101000000001", + "11100011010111111010100100110001101000000010", + "11100011010111111010100100110001101000000011", + "11100011010111111010100100110001101000000100", + "11100011010111111010100100110001101000000101", + "11100011010111111010100100110001101000000110", + "11100011010111111010100100110001101000000111", + "11100011010111111010100100110001101000001000", + "11100011010111111010100100110001101000001001", + "11100011010111111010100100110001101000001010", + "11100011010111111010100100110001101000001011", + "111000110101111110101001001100011010000011000000", + "111000110101111110101001001100011010000011000001", + "111000110101111110101001001100011010000011000010", + "111000110101111110101001001100011010000011000011", + "111000110101111110101001001100011010000011000100", + "111000110101111110101001001100011010000011000101", + "111000110101111110101001001100011010000011000110", + "111000110101111110101001001100011010000011000111", + "111000110101111110101001001100011010000011001000", + "111000110101111110101001001100011010000011001001", + "111000110101111110101001001100011010000011001010", + "111000110101111110101001001100011010000011001011", + "111000110101111110101001001100011010000011001100", + "111000110101111110101001001100011010000011001101", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101000000", + "0000000000000111000110101111110101001001100011010000010", + "0000000000000111000110101111110101001001100011010000011000", + "00000000000001110001101011111101010010011000110100000110010", + "000000000000011100011010111111010100100110001101000001100110", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101000000", + "00000000000001110001101011111101010010011000110100000100", + "00000000000001110001101011111101010010011000110100000101", + "0000000000000111000110101111110101001001100011010000011000", + "000000000000011100011010111111010100100110001101000001100100", + "000000000000011100011010111111010100100110001101000001100101", + "000000000000011100011010111111010100100110001101000001100110", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101000000", + "000000000000011100011010111111010100100110001101000001000", + "000000000000011100011010111111010100100110001101000001001", + "000000000000011100011010111111010100100110001101000001010", + "000000000000011100011010111111010100100110001101000001011", + "000000000000011100011010111111010100100110001101000001100000", + "000000000000011100011010111111010100100110001101000001100001", + "000000000000011100011010111111010100100110001101000001100010", + "000000000000011100011010111111010100100110001101000001100011", + "000000000000011100011010111111010100100110001101000001100100", + "000000000000011100011010111111010100100110001101000001100101", + "000000000000011100011010111111010100100110001101000001100110", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "00000000000001110001101011111101010010011000110100000000", + "00000000000001110001101011111101010010011000110100000001", + "00000000000001110001101011111101010010011000110100000010", + "00000000000001110001101011111101010010011000110100000011", + "00000000000001110001101011111101010010011000110100000100", + "00000000000001110001101011111101010010011000110100000101", + "000000000000011100011010111111010100100110001101000001100000", + "000000000000011100011010111111010100100110001101000001100001", + "000000000000011100011010111111010100100110001101000001100010", + "000000000000011100011010111111010100100110001101000001100011", + "000000000000011100011010111111010100100110001101000001100100", + "000000000000011100011010111111010100100110001101000001100101", + "000000000000011100011010111111010100100110001101000001100110", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "00000000001", + "0000000001", + "000000001", + "00000001", + "0000001", + "000001", + "00001", + "0001", + "001", + "010", + "011000", + "0110010", + "01100110", + "01100111000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000000010", + "0000000000000000000000000000000000000000000000000000011000", + "00000000000000000000000000000000000000000000000000000110010", + "000000000000000000000000000000000000000000000000000001100110", + "000000000000000000000000000000000000000000000000000001100111000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000000000000010", + "000000000000000000000000000000000000000000000000000000000000011", + "000000000000000000000000000000000000000000000000000000000000100", + "000000000000000000000000000000000000000000000000000000000000101", + "000000000000000000000000000000000000000000000000000000000000110", + "000000000000000000000000000000000000000000000000000000000000111", + "000000000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000000000010", + "000000000000000000000000000000000000000000000000000000000011", + "000000000000000000000000000000000000000000000000000000000100", + "000000000000000000000000000000000000000000000000000000000101", + "000000000000000000000000000000000000000000000000000000000110", + "000000000000000000000000000000000000000000000000000000000111", + "000000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000000010", + "000000000000000000000000000000000000000000000000000000011", + "000000000000000000000000000000000000000000000000000000100", + "000000000000000000000000000000000000000000000000000000101", + "000000000000000000000000000000000000000000000000000000110", + "000000000000000000000000000000000000000000000000000000111", + "000000000000000000000000000000000000000000000000000001000", + "000000000000000000000000000000000000000000000000000001001", + "000000000000000000000000000000000000000000000000000001010", + "000000000000000000000000000000000000000000000000000001011", + "000000000000000000000000000000000000000000000000000001100000", + "000000000000000000000000000000000000000000000000000001100001", + "000000000000000000000000000000000000000000000000000001100010", + "000000000000000000000000000000000000000000000000000001100011", + "000000000000000000000000000000000000000000000000000001100100", + "000000000000000000000000000000000000000000000000000001100101", + "000000000000000000000000000000000000000000000000000001100110", + "000000000000000000000000000000000000000000000000000001100111000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "00", + "010", + "011000", + "0110010", + "01100110", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "00", + "0100", + "0101", + "011000", + "01100100", + "01100101", + "01100110", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "000", + "001", + "010", + "011000", + "011001000", + "011001001", + "011001010", + "011001011", + "011001100", + "011001101", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "0000", + "0001", + "0010", + "0011", + "0100", + "0101", + "01100000", + "01100001", + "01100010", + "01100011", + "01100100", + "01100101", + "01100110", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000", + "0000000000000000000000000000000000000000000000000000010", + "0000000000000000000000000000000000000000000000000000011000", + "00000000000000000000000000000000000000000000000000000110010", + "000000000000000000000000000000000000000000000000000001100110", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000", + "00000000000000000000000000000000000000000000000000000100", + "00000000000000000000000000000000000000000000000000000101", + "0000000000000000000000000000000000000000000000000000011000", + "000000000000000000000000000000000000000000000000000001100100", + "000000000000000000000000000000000000000000000000000001100101", + "000000000000000000000000000000000000000000000000000001100110", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000", + "000000000000000000000000000000000000000000000000000001000", + "000000000000000000000000000000000000000000000000000001001", + "000000000000000000000000000000000000000000000000000001010", + "000000000000000000000000000000000000000000000000000001011", + "000000000000000000000000000000000000000000000000000001100000", + "000000000000000000000000000000000000000000000000000001100001", + "000000000000000000000000000000000000000000000000000001100010", + "000000000000000000000000000000000000000000000000000001100011", + "000000000000000000000000000000000000000000000000000001100100", + "000000000000000000000000000000000000000000000000000001100101", + "000000000000000000000000000000000000000000000000000001100110", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 4, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "00000000000000000000000000000000000000000000000000000000", + "00000000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000000000010", + "00000000000000000000000000000000000000000000000000000011", + "00000000000000000000000000000000000000000000000000000100", + "00000000000000000000000000000000000000000000000000000101", + "000000000000000000000000000000000000000000000000000001100000", + "000000000000000000000000000000000000000000000000000001100001", + "000000000000000000000000000000000000000000000000000001100010", + "000000000000000000000000000000000000000000000000000001100011", + "000000000000000000000000000000000000000000000000000001100100", + "000000000000000000000000000000000000000000000000000001100101", + "000000000000000000000000000000000000000000000000000001100110", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "1110001101011111101010010011000110100000", + "11100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "1110001101011111101010010011000110100000", + "11100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "00000000000001110001101011111101010010011000110100000", + "000000000000011100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101000000", + "000000000000011100011010111111010100100110001101000001", + "000000000000011100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "00000000001", + "0000000001", + "000000001", + "00000001", + "0000001", + "000001", + "00001", + "0001", + "001", + "01", + "1000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000000001000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000000000000010", + "000000000000000000000000000000000000000000000000000000000000011", + "000000000000000000000000000000000000000000000000000000000000100", + "000000000000000000000000000000000000000000000000000000000000101", + "000000000000000000000000000000000000000000000000000000000000110", + "000000000000000000000000000000000000000000000000000000000000111", + "000000000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000000000010", + "000000000000000000000000000000000000000000000000000000000011", + "000000000000000000000000000000000000000000000000000000000100", + "000000000000000000000000000000000000000000000000000000000101", + "000000000000000000000000000000000000000000000000000000000110", + "000000000000000000000000000000000000000000000000000000000111", + "000000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000000010", + "000000000000000000000000000000000000000000000000000000011", + "000000000000000000000000000000000000000000000000000000100", + "000000000000000000000000000000000000000000000000000000101", + "000000000000000000000000000000000000000000000000000000110", + "000000000000000000000000000000000000000000000000000000111", + "000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000010000000000", + "000000000000000000000000000000000000000000000000000010000000001", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "0", + "10000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "00000000000000000000000000000000000000000000000000000", + "000000000000000000000000000000000000000000000000000010000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000", + "000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000010000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101", + "00000000000001110001101011111101010010011000111", + "00000000000001110001101011111101010010011001", + "0000000000000111000110101111110101001001101", + "000000000000011100011010111111010100100111", + "000000000000011100011010111111010100101", + "00000000000001110001101011111101010011", + "000000000000011100011010111111010101", + "00000000000001110001101011111101011", + "000000000000011100011010111111011", + "00000000000001110001101011111110000", + "0000000000000111000110101111111000100", + "0000000000000111000110101111111000101000", + "00000000000001110001101011111110001010010", + "000000000000011100011010111111100010100110000", + "0000000000000111000110101111111000101001100010", + "000000000000011100011010111111100010100110001100", + "000000000000011100011010111111100010100110001101000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101", + "000000000000011100011010111111010100100110001110", + "000000000000011100011010111111010100100110001111", + "000000000000011100011010111111010100100110010", + "000000000000011100011010111111010100100110011", + "000000000000011100011010111111010100100110100", + "000000000000011100011010111111010100100110101", + "000000000000011100011010111111010100100110110", + "000000000000011100011010111111010100100110111", + "000000000000011100011010111111010100100111", + "000000000000011100011010111111010100101", + "000000000000011100011010111111010100110", + "000000000000011100011010111111010100111", + "000000000000011100011010111111010101", + "000000000000011100011010111111010110", + "000000000000011100011010111111010111", + "000000000000011100011010111111011", + "000000000000011100011010111111100000", + "000000000000011100011010111111100001", + "000000000000011100011010111111100010000", + "000000000000011100011010111111100010001", + "000000000000011100011010111111100010010", + "000000000000011100011010111111100010011", + "000000000000011100011010111111100010100000", + "000000000000011100011010111111100010100001", + "000000000000011100011010111111100010100010", + "000000000000011100011010111111100010100011", + "000000000000011100011010111111100010100100", + "000000000000011100011010111111100010100101", + "000000000000011100011010111111100010100110000", + "000000000000011100011010111111100010100110001000", + "000000000000011100011010111111100010100110001001", + "000000000000011100011010111111100010100110001010", + "000000000000011100011010111111100010100110001011", + "000000000000011100011010111111100010100110001100", + "000000000000011100011010111111100010100110001101000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000001", + "0000000000000000000000000000000000000001", + "000000000000000000000000000000000000001", + "00000000000000000000000000000000000001", + "0000000000000000000000000000000000001", + "000000000000000000000000000000000001", + "00000000000000000000000000000000001", + "0000000000000000000000000000000001", + "0000000000000000000000000000000010", + "00000000000000000000000000000000110", + "00000000000000000000000000000000111000000000000000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000", + "0000000000000000000000000000000010", + "00000000000000000000000000000000110", + "000000000000000000000000000000001110000000000000000000000000000", + }, +}, +{ + .lowerBound = 0, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000", + "000000000000000000000000000000001000", + "000000000000000000000000000000001001", + "000000000000000000000000000000001010", + "000000000000000000000000000000001011", + "000000000000000000000000000000001100", + "000000000000000000000000000000001101", + "000000000000000000000000000000001110000000000000000000000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001101000001100110111", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001101000001100110111", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101000001100110111", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101000001100110111", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "01100111000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000001100111000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000001100111000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "01100110111", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000001100110111", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 823, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000001100110111", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001101000001100110111", + "11100011010111111010100100110001101000001100111", + "11100011010111111010100100110001101000001101", + "1110001101011111101010010011000110100000111", + "11100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001101000001100110111", + "111000110101111110101001001100011010000011001110", + "111000110101111110101001001100011010000011001111", + "11100011010111111010100100110001101000001101", + "11100011010111111010100100110001101000001110", + "11100011010111111010100100110001101000001111", + "11100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101000001100110111", + "000000000000011100011010111111010100100110001101000001100111", + "000000000000011100011010111111010100100110001101000001101", + "00000000000001110001101011111101010010011000110100000111", + "000000000000011100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101000001100110111", + "000000000000011100011010111111010100100110001101000001100111", + "000000000000011100011010111111010100100110001101000001101", + "000000000000011100011010111111010100100110001101000001110", + "000000000000011100011010111111010100100110001101000001111", + "000000000000011100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "01100111", + "01101", + "0111", + "1000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "01100111", + "011010", + "011011", + "0111", + "1000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000001100111", + "000000000000000000000000000000000000000000000000000001101", + "00000000000000000000000000000000000000000000000000000111", + "00000000000000000000000000000000000000000000000000001000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000001100111", + "0000000000000000000000000000000000000000000000000000011010", + "0000000000000000000000000000000000000000000000000000011011", + "00000000000000000000000000000000000000000000000000000111", + "00000000000000000000000000000000000000000000000000001000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000001100111", + "000000000000000000000000000000000000000000000000000001101", + "000000000000000000000000000000000000000000000000000001110", + "000000000000000000000000000000000000000000000000000001111", + "000000000000000000000000000000000000000000000000000010000000000", + "000000000000000000000000000000000000000000000000000010000000001", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "01100110111", + "01100111", + "01101", + "0111", + "10000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000001100110111", + "000000000000000000000000000000000000000000000000000001100111", + "000000000000000000000000000000000000000000000000000001101", + "00000000000000000000000000000000000000000000000000000111", + "000000000000000000000000000000000000000000000000000010000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000001100110111", + "000000000000000000000000000000000000000000000000000001100111", + "000000000000000000000000000000000000000000000000000001101", + "000000000000000000000000000000000000000000000000000001110", + "000000000000000000000000000000000000000000000000000001111", + "000000000000000000000000000000000000000000000000000010000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101000001100110111", + "000000000000011100011010111111010100100110001101000001100111", + "000000000000011100011010111111010100100110001101000001101", + "00000000000001110001101011111101010010011000110100000111", + "00000000000001110001101011111101010010011000110100001", + "0000000000000111000110101111110101001001100011010001", + "000000000000011100011010111111010100100110001101001", + "00000000000001110001101011111101010010011000110101", + "0000000000000111000110101111110101001001100011011", + "00000000000001110001101011111101010010011000111", + "00000000000001110001101011111101010010011001", + "0000000000000111000110101111110101001001101", + "000000000000011100011010111111010100100111", + "000000000000011100011010111111010100101", + "00000000000001110001101011111101010011", + "000000000000011100011010111111010101", + "00000000000001110001101011111101011", + "000000000000011100011010111111011", + "00000000000001110001101011111110000", + "0000000000000111000110101111111000100", + "0000000000000111000110101111111000101000", + "00000000000001110001101011111110001010010", + "000000000000011100011010111111100010100110000", + "0000000000000111000110101111111000101001100010", + "000000000000011100011010111111100010100110001100", + "000000000000011100011010111111100010100110001101000000000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000001100111", + "000000000000000000000000000000000000000000000000000001101", + "00000000000000000000000000000000000000000000000000000111", + "00000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000001", + "0000000000000000000000000000000000000001", + "000000000000000000000000000000000000001", + "00000000000000000000000000000000000001", + "0000000000000000000000000000000000001", + "000000000000000000000000000000000001", + "00000000000000000000000000000000001", + "0000000000000000000000000000000001", + "0000000000000000000000000000000010", + "00000000000000000000000000000000110", + "00000000000000000000000000000000111000000000000000000000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000001100111", + "0000000000000000000000000000000000000000000000000000011010", + "0000000000000000000000000000000000000000000000000000011011", + "00000000000000000000000000000000000000000000000000000111", + "000000000000000000000000000000000000000000000000000010", + "000000000000000000000000000000000000000000000000000011", + "0000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000010", + "0000000000000000000000000000000000000000000000000011", + "00000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000010", + "00000000000000000000000000000000000000000000000011", + "000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000010", + "000000000000000000000000000000000000000000000011", + "0000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000010", + "0000000000000000000000000000000000000000000011", + "00000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000010", + "00000000000000000000000000000000000000000011", + "000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000010", + "000000000000000000000000000000000000000011", + "0000000000000000000000000000000000000001", + "0000000000000000000000000000000000000010", + "0000000000000000000000000000000000000011", + "00000000000000000000000000000000000001", + "00000000000000000000000000000000000010", + "00000000000000000000000000000000000011", + "000000000000000000000000000000000001", + "000000000000000000000000000000000010", + "000000000000000000000000000000000011", + "0000000000000000000000000000000001", + "0000000000000000000000000000000010", + "000000000000000000000000000000001100", + "000000000000000000000000000000001101", + "00000000000000000000000000000000111000000000000000000000000000", + }, +}, +{ + .lowerBound = 823, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000001100110111", + "000000000000000000000000000000000000000000000000000001100111", + "000000000000000000000000000000000000000000000000000001101", + "00000000000000000000000000000000000000000000000000000111", + "00000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000001", + "0000000000000000000000000000000000000001", + "000000000000000000000000000000000000001", + "00000000000000000000000000000000000001", + "0000000000000000000000000000000000001", + "000000000000000000000000000000000001", + "00000000000000000000000000000000001", + "0000000000000000000000000000000001", + "0000000000000000000000000000000010", + "00000000000000000000000000000000110", + "000000000000000000000000000000001110000000000000000000000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 2, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "11100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101000010000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "10000000001", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000010000000001", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000010000000001", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 1024 }, + .expectMincoverStrings = { + "10000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000010000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000010000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 1024 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1024, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 1024 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000000000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "00000000000001110001101011111101010010011000110100001", + "0000000000000111000110101111110101001001100011010001", + "000000000000011100011010111111010100100110001101001", + "00000000000001110001101011111101010010011000110101", + "0000000000000111000110101111110101001001100011011", + "00000000000001110001101011111101010010011000111", + "00000000000001110001101011111101010010011001", + "0000000000000111000110101111110101001001101", + "000000000000011100011010111111010100100111", + "000000000000011100011010111111010100101", + "00000000000001110001101011111101010011", + "000000000000011100011010111111010101", + "00000000000001110001101011111101011", + "000000000000011100011010111111011", + "00000000000001110001101011111110000", + "0000000000000111000110101111111000100", + "0000000000000111000110101111111000101000", + "00000000000001110001101011111110001010010", + "000000000000011100011010111111100010100110000", + "0000000000000111000110101111111000101001100010", + "000000000000011100011010111111100010100110001100", + "000000000000011100011010111111100010100110001101000000000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111010100100110001101000010", + "000000000000011100011010111111010100100110001101000011", + "000000000000011100011010111111010100100110001101000100", + "000000000000011100011010111111010100100110001101000101", + "000000000000011100011010111111010100100110001101000110", + "000000000000011100011010111111010100100110001101000111", + "000000000000011100011010111111010100100110001101001", + "000000000000011100011010111111010100100110001101010", + "000000000000011100011010111111010100100110001101011", + "000000000000011100011010111111010100100110001101100", + "000000000000011100011010111111010100100110001101101", + "000000000000011100011010111111010100100110001101110", + "000000000000011100011010111111010100100110001101111", + "000000000000011100011010111111010100100110001110", + "000000000000011100011010111111010100100110001111", + "000000000000011100011010111111010100100110010", + "000000000000011100011010111111010100100110011", + "000000000000011100011010111111010100100110100", + "000000000000011100011010111111010100100110101", + "000000000000011100011010111111010100100110110", + "000000000000011100011010111111010100100110111", + "000000000000011100011010111111010100100111", + "000000000000011100011010111111010100101", + "000000000000011100011010111111010100110", + "000000000000011100011010111111010100111", + "000000000000011100011010111111010101", + "000000000000011100011010111111010110", + "000000000000011100011010111111010111", + "000000000000011100011010111111011", + "000000000000011100011010111111100000", + "000000000000011100011010111111100001", + "000000000000011100011010111111100010000", + "000000000000011100011010111111100010001", + "000000000000011100011010111111100010010", + "000000000000011100011010111111100010011", + "000000000000011100011010111111100010100000", + "000000000000011100011010111111100010100001", + "000000000000011100011010111111100010100010", + "000000000000011100011010111111100010100011", + "000000000000011100011010111111100010100100", + "000000000000011100011010111111100010100101", + "000000000000011100011010111111100010100110000", + "000000000000011100011010111111100010100110001000", + "000000000000011100011010111111100010100110001001", + "000000000000011100011010111111100010100110001010", + "000000000000011100011010111111100010100110001011", + "000000000000011100011010111111100010100110001100", + "000000000000011100011010111111100010100110001101000000000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000000000000000000000010000000001", + "00000000000000000000000000000000000000000000000000001000000001", + "0000000000000000000000000000000000000000000000000000100000001", + "000000000000000000000000000000000000000000000000000010000001", + "00000000000000000000000000000000000000000000000000001000001", + "0000000000000000000000000000000000000000000000000000100001", + "000000000000000000000000000000000000000000000000000010001", + "00000000000000000000000000000000000000000000000000001001", + "0000000000000000000000000000000000000000000000000000101", + "000000000000000000000000000000000000000000000000000011", + "0000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000001", + "0000000000000000000000000000000000000001", + "000000000000000000000000000000000000001", + "00000000000000000000000000000000000001", + "0000000000000000000000000000000000001", + "000000000000000000000000000000000001", + "00000000000000000000000000000000001", + "0000000000000000000000000000000001", + "0000000000000000000000000000000010", + "00000000000000000000000000000000110", + "00000000000000000000000000000000111000000000000000000000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "00000000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000000001", + "0000000000000000000000000000000000000000001", + "000000000000000000000000000000000000000001", + "00000000000000000000000000000000000000001", + "0000000000000000000000000000000000000001", + "000000000000000000000000000000000000001", + "00000000000000000000000000000000000001", + "0000000000000000000000000000000000001", + "000000000000000000000000000000000001", + "00000000000000000000000000000000001", + "0000000000000000000000000000000001", + "0000000000000000000000000000000010", + "00000000000000000000000000000000110", + "000000000000000000000000000000001110000000000000000000000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 1024 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000", + "0000000000000000000000000000000010", + "000000000000000000000000000000001100", + "0000000000000000000000000000000011010", + "00000000000000000000000000000000110110", + "000000000000000000000000000000001101110", + "0000000000000000000000000000000011011110", + "00000000000000000000000000000000110111110", + "000000000000000000000000000000001101111110", + "0000000000000000000000000000000011011111110", + "00000000000000000000000000000000110111111110", + "000000000000000000000000000000001101111111110", + "0000000000000000000000000000000011011111111110", + "00000000000000000000000000000000110111111111110", + "000000000000000000000000000000001101111111111110", + "0000000000000000000000000000000011011111111111110", + "00000000000000000000000000000000110111111111111110", + "000000000000000000000000000000001101111111111111110", + "0000000000000000000000000000000011011111111111111110", + "00000000000000000000000000000000110111111111111111110", + "000000000000000000000000000000001101111111111111111110000000000", + }, +}, +{ + .lowerBound = 1024, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 1024 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000000", + "000000000000000000000000000000001000", + "000000000000000000000000000000001001", + "000000000000000000000000000000001010", + "000000000000000000000000000000001011", + "000000000000000000000000000000001100", + "000000000000000000000000000000001101000", + "000000000000000000000000000000001101001", + "000000000000000000000000000000001101010", + "000000000000000000000000000000001101011", + "000000000000000000000000000000001101100", + "000000000000000000000000000000001101101", + "000000000000000000000000000000001101110", + "000000000000000000000000000000001101111000", + "000000000000000000000000000000001101111001", + "000000000000000000000000000000001101111010", + "000000000000000000000000000000001101111011", + "000000000000000000000000000000001101111100", + "000000000000000000000000000000001101111101", + "000000000000000000000000000000001101111110", + "000000000000000000000000000000001101111111000", + "000000000000000000000000000000001101111111001", + "000000000000000000000000000000001101111111010", + "000000000000000000000000000000001101111111011", + "000000000000000000000000000000001101111111100", + "000000000000000000000000000000001101111111101", + "000000000000000000000000000000001101111111110", + "000000000000000000000000000000001101111111111000", + "000000000000000000000000000000001101111111111001", + "000000000000000000000000000000001101111111111010", + "000000000000000000000000000000001101111111111011", + "000000000000000000000000000000001101111111111100", + "000000000000000000000000000000001101111111111101", + "000000000000000000000000000000001101111111111110", + "000000000000000000000000000000001101111111111111000", + "000000000000000000000000000000001101111111111111001", + "000000000000000000000000000000001101111111111111010", + "000000000000000000000000000000001101111111111111011", + "000000000000000000000000000000001101111111111111100", + "000000000000000000000000000000001101111111111111101", + "000000000000000000000000000000001101111111111111110", + "000000000000000000000000000000001101111111111111111000", + "000000000000000000000000000000001101111111111111111001", + "000000000000000000000000000000001101111111111111111010", + "000000000000000000000000000000001101111111111111111011", + "000000000000000000000000000000001101111111111111111100", + "000000000000000000000000000000001101111111111111111101", + "000000000000000000000000000000001101111111111111111110000000000", + }, +}, +{ + .lowerBound = 1879048192, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111100010100110001101000000000000000", + }, +}, +{ + .lowerBound = 1879048192, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1000000000000000 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000011100011010111111100010100110001101000000000000000", + }, +}, +{ + .lowerBound = 1879048192, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000001110000000000000000000000000001", + }, +}, +{ + .lowerBound = 1879048192, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = -1 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000001110000000000000000000000000001", + }, +}, +{ + .lowerBound = 1879048192, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000001110000000000000000000000000000", + }, +}, +{ + .lowerBound = 1879048192, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 0 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000001110000000000000000000000000000", + }, +}, +{ + .lowerBound = 1879048192, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 1, + .min = { .set = true, .value = 1024 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000001101111111111111111110000000000", + }, +}, +{ + .lowerBound = 1879048192, + .includeLowerBound = true, + .upperBound = 1879048192, + .includeUpperBound = true, + .sparsity = 3, + .min = { .set = true, .value = 1024 }, + .max = { .set = true, .value = 8070450532247928832 }, + .expectMincoverStrings = { + "000000000000000000000000000000001101111111111111111110000000000", + }, }, diff --git a/test/test-mc-range-edge-generation.c b/test/test-mc-range-edge-generation.c index feda37c47..dbc664925 100644 --- a/test/test-mc-range-edge-generation.c +++ b/test/test-mc-range-edge-generation.c @@ -261,6 +261,80 @@ _test_getEdgesDouble (_mongocrypt_tester_t *tester) } } + +#define MAX_DEC128_EDGES 129 +typedef struct { + mc_dec128 value; + mc_optional_dec128_t min; + mc_optional_dec128_t max; + int sparsity; + // expectEdges includes a trailing NULL pointer. + const char *expectEdges[MAX_DEC128_EDGES + 1]; + const char *expectError; +} Decimal128Test; +#undef MAX_DEC128_EDGES + +static void +_test_getEdgesDecimal128 (_mongocrypt_tester_t *tester) +{ + Decimal128Test tests[] = { +#include "data/range-edge-generation/edges_decimal128.cstruct" + }; + + for (size_t i = 0; i < sizeof (tests) / sizeof (tests[0]); i++) { + const Decimal128Test *test = tests + i; + mongocrypt_status_t *const status = mongocrypt_status_new (); + mc_getEdgesDecimal128_args_t args = { + .value = test->value, + // Some edges specify min/max values, but we don't use them (yet) + // .min = test->min, + // .max = test->max, + .sparsity = (size_t) test->sparsity, + }; + mc_edges_t *got = mc_getEdgesDecimal128 (args, status); + + if (test->expectError != NULL) { + if (NULL != got) { + TEST_ERROR ("test %zu expected error, got success", i); + } + ASSERT_STATUS_CONTAINS (status, test->expectError); + mongocrypt_status_destroy (status); + continue; + } + ASSERT_OK_STATUS (got != NULL, status); + + size_t numGot = mc_edges_len (got); + size_t numExpected = 0; + while (test->expectEdges[numExpected] != NULL) { + ++numExpected; + } + + if (numExpected != numGot) { + print_edges_compared (got, test->expectEdges); + TEST_ERROR ("test %zu got %zu edges, expected %zu edges\n", + i, + numGot, + numExpected); + } + for (size_t gotI = 0; gotI < numGot; gotI++) { + const char *edgeGot = mc_edges_get (got, gotI); + const char *edgeExpected = test->expectEdges[gotI]; + if (0 == strcmp (edgeGot, edgeExpected)) { + continue; + } + print_edges_compared (got, test->expectEdges); + TEST_ERROR ("test %zu got edge mismatch at index %zu. (actual) '%s' " + "!= '%s' (expected)\n", + i, + gotI, + edgeGot, + edgeExpected); + } + mc_edges_destroy (got); + mongocrypt_status_destroy (status); + } +} + static void _test_count_leading_zeros (_mongocrypt_tester_t *tester) { @@ -273,6 +347,13 @@ _test_count_leading_zeros (_mongocrypt_tester_t *tester) ASSERT_CMPSIZE_T (mc_count_leading_zeros_u32 (UINT32_C (1)), ==, 31); ASSERT_CMPSIZE_T (mc_count_leading_zeros_u32 (UINT32_MAX), ==, 0); ASSERT_CMPSIZE_T (mc_count_leading_zeros_u32 ((~UINT32_C (0)) >> 1), ==, 1); + + ASSERT_CMPSIZE_T (mc_count_leading_zeros_u128 (MLIB_INT128 (0)), ==, 128); + ASSERT_CMPSIZE_T (mc_count_leading_zeros_u128 (MLIB_INT128 (8)), ==, 124); + ASSERT_CMPSIZE_T ( + mc_count_leading_zeros_u128 ((mlib_int128) MLIB_INT128_FROM_PARTS (0, 8)), + ==, + 60); } typedef struct { @@ -285,6 +366,11 @@ typedef struct { const char *expect; } bitstring_u64_test; +typedef struct { + mlib_int128 in; + const char *expect; +} bitstring_u128_test; + static void _test_convert_to_bitstring (_mongocrypt_tester_t *tester) { @@ -298,9 +384,8 @@ _test_convert_to_bitstring (_mongocrypt_tester_t *tester) {.in = UINT32_MAX - 1u, .expect = "11111111111111111111111111111110"}}; for (size_t i = 0; i < sizeof (tests) / sizeof (tests[0]); i++) { bitstring_u32_test *test = tests + i; - char *got = mc_convert_to_bitstring_u32 (test->in); - ASSERT_STREQUAL (test->expect, got); - bson_free (got); + mc_bitstring got = mc_convert_to_bitstring_u32 (test->in); + ASSERT_STREQUAL (test->expect, got.str); } } // Test uint64_t. @@ -323,9 +408,46 @@ _test_convert_to_bitstring (_mongocrypt_tester_t *tester) "111110"}}; for (size_t i = 0; i < sizeof (tests) / sizeof (tests[0]); i++) { bitstring_u64_test *test = tests + i; - char *got = mc_convert_to_bitstring_u64 (test->in); - ASSERT_STREQUAL (test->expect, got); - bson_free (got); + mc_bitstring got = mc_convert_to_bitstring_u64 (test->in); + ASSERT_STREQUAL (test->expect, got.str); + } + } + // Tests for u128 + { + bitstring_u128_test tests[] = { + { + .in = MLIB_INT128 (0), + .expect = "00000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000" + "0000000000000000", + }, + { + .in = MLIB_INT128 (1), + .expect = "00000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000" + "0000000000000001", + }, + { + .in = MLIB_INT128 (256), + .expect = "00000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000" + "0000000100000000", + }, + { + .in = mlib_int128_from_string ( + "0b1011010010001011101010010100101010010101010101001010010100100" + "101010101010010001010011010110110100110010101010010101001111010" + "1011", + NULL), + .expect = "10110100100010111010100101001010100101010101010010100101" + "00100101010101010010001010011010110110100110010101010010" + "1010011110101011", + }, + }; + for (size_t i = 0; i < sizeof (tests) / sizeof (tests[0]); i++) { + bitstring_u128_test *test = tests + i; + mc_bitstring got = mc_convert_to_bitstring_u128 (test->in); + ASSERT_STREQUAL (test->expect, got.str); } } } @@ -336,6 +458,7 @@ _mongocrypt_tester_install_range_edge_generation (_mongocrypt_tester_t *tester) INSTALL_TEST (_test_getEdgesInt32); INSTALL_TEST (_test_getEdgesInt64); INSTALL_TEST (_test_getEdgesDouble); + INSTALL_TEST (_test_getEdgesDecimal128); INSTALL_TEST (_test_count_leading_zeros); INSTALL_TEST (_test_convert_to_bitstring); } diff --git a/test/test-mc-range-encoding.c b/test/test-mc-range-encoding.c index 5594ca9b0..f9dfbcc91 100644 --- a/test/test-mc-range-encoding.c +++ b/test/test-mc-range-encoding.c @@ -524,10 +524,358 @@ _test_RangeTest_Encode_Double (_mongocrypt_tester_t *tester) } } + +typedef struct { + mc_dec128 value; + mc_optional_dec128_t min; + mc_optional_dec128_t max; + mc_optional_uint32_t precision; + mlib_int128 expect; + const char *expectError; +} Decimal128Test; + +static void +_test_RangeTest_Encode_Decimal128 (_mongocrypt_tester_t *tester) +{ + Decimal128Test tests[] = { +#define CASE(Value, ExpectStr) \ + (Decimal128Test){.value = mc_dec128_from_string (#Value), \ + .expect = mlib_int128_from_string (ExpectStr, NULL)} + /* Test cases copied from server Decimal128_Bounds test ... begin */ + // Larger numbers map to larger int128 + CASE (-1234567890E7, "108549948892579231731687303715884111887"), + CASE (-1234567890E6, "108559948892579231731687303715884111886"), + CASE (-1234567890E5, "108569948892579231731687303715884111885"), + CASE (-1234567890E4, "108579948892579231731687303715884111884"), + CASE (-1234567890E3, "108589948892579231731687303715884111883"), + CASE (-1234567890E2, "108599948892579231731687303715884111882"), + CASE (-1234567890E1, "108609948892579231731687303715884111881"), + CASE (-123456789012345, "108569948892579108281687303715884111885"), + CASE (-12345678901234, "108579948892579108331687303715884111884"), + CASE (-1234567890123, "108589948892579108731687303715884111883"), + CASE (-123456789012, "108599948892579111731687303715884111882"), + CASE (-12345678901, "108609948892579131731687303715884111881"), + CASE (-1234567890, "108619948892579231731687303715884111880"), + CASE (-99999999, "108631183460569231731687303715884111878"), + CASE (-8888888, "108642294572469231731687303715884111877"), + CASE (-777777, "108653405690469231731687303715884111876"), + CASE (-66666, "108664516860469231731687303715884111875"), + CASE (-5555, "108675628460469231731687303715884111874"), + CASE (-444, "108686743460469231731687303715884111873"), + CASE (-334, "108687843460469231731687303715884111873"), + CASE (-333, "108687853460469231731687303715884111873"), + CASE (-44, "108696783460469231731687303715884111872"), + CASE (-33, "108697883460469231731687303715884111872"), + CASE (-22, "108698983460469231731687303715884111872"), + CASE (-5, "108706183460469231731687303715884111871"), + CASE (-4, "108707183460469231731687303715884111871"), + CASE (-3, "108708183460469231731687303715884111871"), + CASE (-2, "108709183460469231731687303715884111871"), + CASE (-1, "108710183460469231731687303715884111871"), + CASE (0, "170141183460469231731687303715884105728"), + CASE (1, "231572183460469231731687303715884099585"), + CASE (2, "231573183460469231731687303715884099585"), + CASE (3, "231574183460469231731687303715884099585"), + CASE (4, "231575183460469231731687303715884099585"), + CASE (5, "231576183460469231731687303715884099585"), + CASE (22, "231583383460469231731687303715884099584"), + CASE (33, "231584483460469231731687303715884099584"), + CASE (44, "231585583460469231731687303715884099584"), + CASE (333, "231594513460469231731687303715884099583"), + CASE (334, "231594523460469231731687303715884099583"), + CASE (444, "231595623460469231731687303715884099583"), + CASE (5555, "231606738460469231731687303715884099582"), + CASE (66666, "231617850060469231731687303715884099581"), + CASE (777777, "231628961230469231731687303715884099580"), + CASE (8888888, "231640072348469231731687303715884099579"), + CASE (33E56, "232144483460469231731687303715884099528"), + CASE (22E57, "232153383460469231731687303715884099527"), + CASE (11E58, "232162283460469231731687303715884099526"), + + // Smaller exponents map to smaller int128 + CASE (1E-6, "231512183460469231731687303715884099591"), + CASE (1E-7, "231502183460469231731687303715884099592"), + CASE (1E-8, "231492183460469231731687303715884099593"), + CASE (1E-56, "231012183460469231731687303715884099641"), + CASE (1E-57, "231002183460469231731687303715884099642"), + CASE (1E-58, "230992183460469231731687303715884099643"), + + // Smaller negative exponents map to smaller int128 + CASE (-1E-6, "108770183460469231731687303715884111865"), + CASE (-1E-7, "108780183460469231731687303715884111864"), + CASE (-1E-8, "108790183460469231731687303715884111863"), + CASE (-1E-56, "109270183460469231731687303715884111815"), + CASE (-1E-57, "109280183460469231731687303715884111814"), + CASE (-1E-58, "109290183460469231731687303715884111813"), + + // Larger exponents map to larger int128 + CASE (-33E56, "108137883460469231731687303715884111928"), + CASE (-22E57, "108128983460469231731687303715884111929"), + CASE (-11E58, "108120083460469231731687303715884111930"), + + (Decimal128Test){.value = MC_DEC128_LARGEST_POSITIVE, + .expect = mlib_int128_from_string ( + "293021183460469231731687303715884093440", NULL)}, + (Decimal128Test){.value = MC_DEC128_SMALLEST_POSITIVE, + .expect = mlib_int128_from_string ( + "170141183460469231731687303715884105729", NULL)}, + (Decimal128Test){.value = MC_DEC128_LARGEST_NEGATIVE, + .expect = mlib_int128_from_string ( + "47261183460469231731687303715884118016", NULL)}, + (Decimal128Test){.value = MC_DEC128_SMALLEST_NEGATIVE, + .expect = mlib_int128_from_string ( + "170141183460469231731687303715884105727", NULL)}, + (Decimal128Test){.value = MC_DEC128_NORMALIZED_ZERO, + .expect = mlib_int128_from_string ( + "170141183460469231731687303715884105728", NULL)}, + (Decimal128Test){.value = MC_DEC128_NEGATIVE_EXPONENT_ZERO, + .expect = mlib_int128_from_string ( + "170141183460469231731687303715884105728", NULL)}, + /* Test cases copied from server Decimal128_Bounds test ... end */ + +#define ERROR_CASE(Value, Min, Max, Precision, ErrorString) \ + (Decimal128Test){ \ + .value = Value, \ + .min = Min, \ + .max = Max, \ + .precision = Precision, \ + .expectError = ErrorString, \ + } + + ERROR_CASE ( + MC_DEC128_C (1), + OPT_NULLOPT, + OPT_MC_DEC128 (MC_DEC128_C (2)), + OPT_U32 (5), + "min, max, and precision must all be set or must all be unset"), + ERROR_CASE ( + MC_DEC128_C (1), + OPT_MC_DEC128 (MC_DEC128_C (0)), + OPT_NULLOPT, + OPT_U32 (5), + "min, max, and precision must all be set or must all be unset"), + ERROR_CASE (MC_DEC128_C (1), + OPT_MC_DEC128 (MC_DEC128_C (2)), + OPT_MC_DEC128 (MC_DEC128_C (1)), + OPT_U32 (5), + "The minimum value must be less than the maximum value"), + + ERROR_CASE (MC_DEC128_C (1), + OPT_MC_DEC128 (MC_DEC128_C (2)), + OPT_MC_DEC128 (MC_DEC128_C (3)), + OPT_U32 (5), + "Value must be greater than or equal to the minimum value " + "and less than or equal to the maximum value"), + ERROR_CASE (MC_DEC128_C (4), + OPT_MC_DEC128 (MC_DEC128_C (2)), + OPT_MC_DEC128 (MC_DEC128_C (3)), + OPT_U32 (5), + "Value must be greater than or equal to the minimum value " + "and less than or equal to the maximum value"), + + ERROR_CASE (MC_DEC128_POSITIVE_INFINITY, + OPT_NULLOPT, + OPT_NULLOPT, + OPT_NULLOPT, + "Infinity and Nan Decimal128 values are not supported."), + ERROR_CASE (MC_DEC128_NEGATIVE_INFINITY, + OPT_NULLOPT, + OPT_NULLOPT, + OPT_NULLOPT, + "Infinity and Nan Decimal128 values are not supported."), + + ERROR_CASE (MC_DEC128_POSITIVE_NAN, + OPT_NULLOPT, + OPT_NULLOPT, + OPT_NULLOPT, + "Infinity and Nan Decimal128 values are not supported."), + + ERROR_CASE (MC_DEC128_NEGATIVE_NAN, + OPT_NULLOPT, + OPT_NULLOPT, + OPT_NULLOPT, + "Infinity and Nan Decimal128 values are not supported."), + +/* Test cases copied from Decimal128_Bounds_Precision ... begin */ +#define ASSERT_EIBP(Value, Precision, Expect) \ + (Decimal128Test){ \ + .value = mc_dec128_from_string (Value), \ + .min = OPT_MC_DEC128 (MC_DEC128_C (-100000)), \ + .max = OPT_MC_DEC128 (MC_DEC128_C (100000)), \ + .precision = OPT_U32 (Precision), \ + .expect = MLIB_INT128 (Expect), \ + } + ASSERT_EIBP ("3.141592653589E-1", 10, 1000003141592653), + ASSERT_EIBP ("31.41592653589E-2", 10, 1000003141592653), + ASSERT_EIBP ("314.1592653589E-3", 10, 1000003141592653), + ASSERT_EIBP ("3141.592653589E-4", 10, 1000003141592653), + ASSERT_EIBP ("31415.92653589E-5", 10, 1000003141592653), + ASSERT_EIBP ("314159.2653589E-6", 10, 1000003141592653), + ASSERT_EIBP ("3141592.653589E-7", 10, 1000003141592653), + ASSERT_EIBP ("31415926.53589E-8", 10, 1000003141592653), +#undef ASSERT_EIBP + +#define ASSERT_EIBPL(Value, Precision, Expect) \ + (Decimal128Test){ \ + .value = mc_dec128_from_string (Value), \ + .min = OPT_MC_DEC128 (MC_DEC128_C (-100000)), \ + .max = OPT_MC_DEC128 (mc_dec128_from_string ("1E22")), \ + .precision = OPT_U32 (Precision), \ + .expect = mlib_int128_from_string (Expect, NULL), \ + } + + ASSERT_EIBPL ("3.1415926535897932384626433832795E20", + 5, + "31415926535897942384626433"), + ASSERT_EIBPL ("3.1415926535897932384626433832795E20", + 6, + "314159265358979423846264338"), + + ASSERT_EIBPL ("3.1415926535897932384626433832795E20", + 7, + "3141592653589794238462643383"), + + ASSERT_EIBPL ("3.1415926535897932384626433832795E20", + 8, + "31415926535897942384626433832"), +#undef ASSERT_EIBPL + +#define ASSERT_EIBP(Value, Precision, Expect) \ + (Decimal128Test){ \ + .value = mc_dec128_from_string (#Value), \ + .min = OPT_MC_DEC128 (MC_DEC128_C (-100000)), \ + .max = OPT_MC_DEC128 (MC_DEC128_C (100000)), \ + .precision = OPT_U32 (Precision), \ + .expect = MLIB_INT128_CAST (Expect), \ + } + ASSERT_EIBP (3.141592653589, 1, 1000031), + ASSERT_EIBP (3.141592653589, 2, 10000314), + ASSERT_EIBP (3.141592653589, 3, 100003141), + ASSERT_EIBP (3.141592653589, 4, 1000031415), + ASSERT_EIBP (3.141592653589, 5, 10000314159), + ASSERT_EIBP (3.141592653589, 6, 100003141592), + ASSERT_EIBP (3.141592653589, 7, 1000031415926), +#undef ASSERT_EIBP + +#define ASSERT_EIBB(Val, Max, Min, Precision, Expect) \ + (Decimal128Test){ \ + .value = mc_dec128_from_string (#Val), \ + .min = OPT_MC_DEC128 (mc_dec128_from_string (#Min)), \ + .max = OPT_MC_DEC128 (mc_dec128_from_string (#Max)), \ + .precision = OPT_U32 (Precision), \ + .expect = MLIB_INT128_CAST (Expect), \ + } + +#define ASSERT_EIBB_OVERFLOW(Val, Max, Min, Precision, Expect) \ + (Decimal128Test) \ + { \ + .value = mc_dec128_from_string (#Val), \ + .min = OPT_MC_DEC128 (mc_dec128_from_string (#Min)), \ + .max = OPT_MC_DEC128 (mc_dec128_from_string (#Max)), \ + .precision = OPT_U32 (Precision), .expect = Expect, \ + } + + ASSERT_EIBB (0, 1, -1, 3, 1000), + ASSERT_EIBB (0, 1, -1E5, 3, 100000000), + + ASSERT_EIBB (-1E-33, 1, -1E5, 3, 100000000), + + ASSERT_EIBB_OVERFLOW ( + 0, + MC_DEC128_LARGEST_POSITIVE, + MC_DEC128_LARGEST_NEGATIVE, + 3, + mlib_int128_from_string ("170141183460469231731687303715884105728", + NULL)), + ASSERT_EIBB_OVERFLOW ( + 0, + DBL_MAX, + DBL_MIN, + 3, + mlib_int128_from_string ("170141183460469231731687303715884105728", + NULL)), + + ASSERT_EIBB (3.141592653589, 5, 0, 0, 3), + ASSERT_EIBB (3.141592653589, 5, 0, 1, 31), + + ASSERT_EIBB (3.141592653589, 5, 0, 2, 314), + + ASSERT_EIBB (3.141592653589, 5, 0, 3, 3141), + ASSERT_EIBB (3.141592653589, 5, 0, 16, 31415926535890000), + + ASSERT_EIBB (-5, -1, -10, 3, 5000), + + ASSERT_EIBB_OVERFLOW ( + 1E100, + DBL_MAX, + DBL_MIN, + 3, + mlib_int128_from_string ("232572183460469231731687303715884099485", + NULL)), + + ASSERT_EIBB (1E9, 1E10, 0, 3, 1000000000000), + ASSERT_EIBB (1E9, 1E10, 0, 0, 1000000000), + + + ASSERT_EIBB (-5, 10, -10, 0, 5), + ASSERT_EIBB (-5, 10, -10, 2, 500), + + ASSERT_EIBB (5E-30, 10E-30, 1E-30, 35, 400000), + + // Test a range that requires > 64 bits. + ASSERT_EIBB (5, 18446744073709551616, .1, 1, 49), + // Test a range that requires > 64 bits. + // min has more places after the decimal than precision. + ASSERT_EIBB (5, 18446744073709551616, .01, 1, 49), + +#undef ASSERT_EIBB +#undef ASSERT_EIBB_OVERFLOW + + /* Test cases copied from Decimal128_Bounds_Precision ... end */ + }; + + for (size_t i = 0; i < sizeof (tests) / sizeof (tests[0]); i++) { + Decimal128Test *test = tests + i; + mongocrypt_status_t *const status = mongocrypt_status_new (); + + if (test->min.set && test->max.set && test->precision.set) { + printf ("_test_RangeTest_Encode_Decimal128: value=%s, min=%s, max=%s, " + "precision=%" PRIu32 "\n", + mc_dec128_to_string (test->value).str, + mc_dec128_to_string (test->min.value).str, + mc_dec128_to_string (test->max.value).str, + test->precision.value); + } else { + printf ("_test_RangeTest_Encode_Decimal128: value=%s\n", + mc_dec128_to_string (test->value).str); + } + fflush (stdout); + mc_OSTType_Decimal128 got; + const bool ok = mc_getTypeInfoDecimal128 ( + (mc_getTypeInfoDecimal128_args_t){.value = test->value, + .min = test->min, + .max = test->max, + .precision = test->precision}, + &got, + status); + if (test->expectError) { + ASSERT_OR_PRINT_MSG (!ok, "expected error, but got none"); + ASSERT_STATUS_CONTAINS (status, test->expectError); + } else { + ASSERT_OK_STATUS (ok, status); + + ASSERT_CMPINT128_EQ (got.value, test->expect); + ASSERT_CMPINT128_EQ (got.min, MLIB_INT128 (0)); + } + mongocrypt_status_destroy (status); + } +} + void _mongocrypt_tester_install_range_encoding (_mongocrypt_tester_t *tester) { INSTALL_TEST (_test_RangeTest_Encode_Int32); INSTALL_TEST (_test_RangeTest_Encode_Int64); INSTALL_TEST (_test_RangeTest_Encode_Double); + INSTALL_TEST (_test_RangeTest_Encode_Decimal128); } diff --git a/test/test-mc-range-mincover.c b/test/test-mc-range-mincover.c index 4262225f2..99b28bb87 100644 --- a/test/test-mc-range-mincover.c +++ b/test/test-mc-range-mincover.c @@ -21,47 +21,14 @@ #include "mc-range-mincover-private.h" #include "mc-array-private.h" -static void -expectMincover_init (mc_array_t *expectMincover, - const char *expectMincoverString) -{ - _mc_array_init (expectMincover, sizeof (char *)); - - const char *curr = expectMincoverString; - const char *ptr = expectMincoverString; - size_t nchars = 0; - while (true) { - if (*ptr == '\n') { - if (nchars > 0) { - char *got = bson_strndup (curr, nchars); - _mc_array_append_val (expectMincover, got); - } - curr = ptr + 1; - ++ptr; - nchars = 0; - continue; - } - if (*ptr == '\0') { - if (nchars > 0) { - char *got = bson_strndup (curr, nchars); - _mc_array_append_val (expectMincover, got); - } - return; - } - ++ptr; - ++nchars; - } -} -static void -expectMincover_cleanup (mc_array_t *expectMincover) -{ - for (size_t i = 0; i < expectMincover->len; i++) { - char *got = _mc_array_index (expectMincover, char *, i); - bson_free (got); - } - _mc_array_destroy (expectMincover); -} +enum { + /// Why this number? The Decimal128 tests generate thousands of test strings, + /// but we can't set this arbitrarily high, since we'll bump up on stack + /// overflow on MSVC. This is large enough to capture all strings in all + /// Decimal128 tests without overflowing the stack. + MAX_MINCOVER_STRINGS = 4500 +}; typedef struct { int32_t lowerBound; @@ -71,9 +38,7 @@ typedef struct { mc_optional_int32_t min; mc_optional_int32_t max; size_t sparsity; - /* expectMincoverString is newline delimitted list of strings. */ - const char *expectMincoverString; - mc_array_t expectMincover; + const char *expectMincoverStrings[MAX_MINCOVER_STRINGS]; const char *expectError; } Int32Test; @@ -85,9 +50,7 @@ typedef struct { mc_optional_int64_t min; mc_optional_int64_t max; size_t sparsity; - /* expectMincoverString is newline delimitted list of strings. */ - const char *expectMincoverString; - mc_array_t expectMincover; + const char *expectMincoverStrings[MAX_MINCOVER_STRINGS]; const char *expectError; } Int64Test; @@ -100,19 +63,29 @@ typedef struct { mc_optional_double_t min; mc_optional_double_t max; mc_optional_uint32_t precision; - /* expectMincoverString is newline delimitted list of strings. */ - const char *expectMincoverString; - mc_array_t expectMincover; + const char *expectMincoverStrings[MAX_MINCOVER_STRINGS]; const char *expectError; } DoubleTest; +typedef struct { + mc_dec128 lowerBound; + bool includeLowerBound; + mc_dec128 upperBound; + bool includeUpperBound; + size_t sparsity; + mc_optional_dec128_t min; + mc_optional_dec128_t max; + mc_optional_uint32_t precision; + const char *expectMincoverStrings[MAX_MINCOVER_STRINGS]; + const char *expectError; +} Decimal128Test; + typedef struct _test_getMincover_args { mc_mincover_t *(*getMincover) (void *tests, size_t idx, mongocrypt_status_t *status); const char *(*expectError) (void *tests, size_t idx); - void (*expectMincover_init) (void *tests, size_t idx); - mc_array_t *(*expectMincover) (void *tests, size_t idx); + const char *const *(*expectMincoverStrings) (void *tests, size_t idx); void (*dump) (void *tests, size_t idx, mc_mincover_t *got); } _test_getMincover_args; @@ -168,8 +141,30 @@ _test_getMincoverDouble_helper (void *tests, .upperBound = test->upperBound, .includeUpperBound = test->includeUpperBound, .sparsity = test->sparsity, - .min = test->min, - .max = test->max, + .min = test->precision.set ? test->min : (mc_optional_double_t){0}, + .max = test->precision.set ? test->max : (mc_optional_double_t){0}, + .precision = test->precision}, + status); +} + +static mc_mincover_t * +_test_getMincoverDecimal128_helper (void *tests, + size_t idx, + mongocrypt_status_t *status) +{ + BSON_ASSERT_PARAM (tests); + + Decimal128Test *const test = (Decimal128Test *) tests + idx; + + return mc_getMincoverDecimal128 ( + (mc_getMincoverDecimal128_args_t){ + .lowerBound = test->lowerBound, + .includeLowerBound = test->includeLowerBound, + .upperBound = test->upperBound, + .includeUpperBound = test->includeUpperBound, + .sparsity = test->sparsity, + .min = test->precision.set ? test->min : (mc_optional_dec128_t){0}, + .max = test->precision.set ? test->max : (mc_optional_dec128_t){0}, .precision = test->precision}, status); } @@ -195,49 +190,39 @@ _test_expectErrorDouble (void *tests, size_t idx) return ((DoubleTest *) tests + idx)->expectError; } -static void -_test_expectMincover_init32 (void *tests, size_t idx) -{ - BSON_ASSERT_PARAM (tests); - Int32Test *const test = (Int32Test *) tests + idx; - expectMincover_init (&test->expectMincover, test->expectMincoverString); -} - -static void -_test_expectMincover_init64 (void *tests, size_t idx) +static const char * +_test_expectErrorDecimal128 (void *tests, size_t idx) { BSON_ASSERT_PARAM (tests); - Int64Test *const test = (Int64Test *) tests + idx; - expectMincover_init (&test->expectMincover, test->expectMincoverString); + return ((Decimal128Test *) tests + idx)->expectError; } -static void -_test_expectMincover_initDouble (void *tests, size_t idx) +static const char *const * +_test_expectMincover32 (void *tests, size_t idx) { BSON_ASSERT_PARAM (tests); - DoubleTest *const test = (DoubleTest *) tests + idx; - expectMincover_init (&test->expectMincover, test->expectMincoverString); + return ((Int32Test *) tests + idx)->expectMincoverStrings; } -static mc_array_t * -_test_expectMincover32 (void *tests, size_t idx) +static const char *const * +_test_expectMincover64 (void *tests, size_t idx) { BSON_ASSERT_PARAM (tests); - return &((Int32Test *) tests + idx)->expectMincover; + return ((Int64Test *) tests + idx)->expectMincoverStrings; } -static mc_array_t * -_test_expectMincover64 (void *tests, size_t idx) +static const char *const * +_test_expectMincoverDouble (void *tests, size_t idx) { BSON_ASSERT_PARAM (tests); - return &((Int64Test *) tests + idx)->expectMincover; + return ((DoubleTest *) tests + idx)->expectMincoverStrings; } -static mc_array_t * -_test_expectMincoverDouble (void *tests, size_t idx) +static const char *const * +_test_expectMincoverDecimal128 (void *tests, size_t idx) { BSON_ASSERT_PARAM (tests); - return &((DoubleTest *) tests + idx)->expectMincover; + return ((Decimal128Test *) tests + idx)->expectMincoverStrings; } static void @@ -260,7 +245,9 @@ _test_dump_32 (void *tests, size_t idx, mc_mincover_t *got) } fprintf (stderr, " sparsity=%zu\n", test->sparsity); fprintf (stderr, "mincover expected ... begin\n"); - fprintf (stderr, "%s", test->expectMincoverString); + for (const char **p = test->expectMincoverStrings; *p; ++p) { + fprintf (stderr, " %s\n", *p); + } fprintf (stderr, "mincover expected ... end\n"); fprintf (stderr, "mincover got ... begin\n"); for (size_t i = 0; i < mc_mincover_len (got); i++) { @@ -289,7 +276,9 @@ _test_dump_64 (void *tests, size_t idx, mc_mincover_t *got) } fprintf (stderr, " sparsity=%zu\n", test->sparsity); fprintf (stderr, "mincover expected ... begin\n"); - fprintf (stderr, "%s", test->expectMincoverString); + for (const char **p = test->expectMincoverStrings; *p; ++p) { + fprintf (stderr, " %s\n", *p); + } fprintf (stderr, "mincover expected ... end\n"); fprintf (stderr, "mincover got ... begin\n"); for (size_t i = 0; i < mc_mincover_len (got); i++) { @@ -321,7 +310,43 @@ _test_dump_Double (void *tests, size_t idx, mc_mincover_t *got) } fprintf (stderr, " sparsity=%zu\n", test->sparsity); fprintf (stderr, "mincover expected ... begin\n"); - fprintf (stderr, "%s", test->expectMincoverString); + for (const char **p = test->expectMincoverStrings; *p; ++p) { + fprintf (stderr, " %s\n", *p); + } + fprintf (stderr, "mincover expected ... end\n"); + fprintf (stderr, "mincover got ... begin\n"); + for (size_t i = 0; i < mc_mincover_len (got); i++) { + fprintf (stderr, " %s\n", mc_mincover_get (got, i)); + } + fprintf (stderr, "mincover got ... end\n"); +} + +static void +_test_dump_Decimal128 (void *tests, size_t idx, mc_mincover_t *got) +{ + BSON_ASSERT_PARAM (tests); + Decimal128Test *const test = (Decimal128Test *) tests + idx; + fflush (stdout); // Avoid incomplete stdout output from prior tests on error + fprintf (stderr, + "testcase: lowerBound=%s (%s) upperBound=%s (%s)", + mc_dec128_to_string (test->lowerBound).str, + test->includeLowerBound ? "inclusive" : "exclusive", + mc_dec128_to_string (test->upperBound).str, + test->includeUpperBound ? "inclusive" : "exclusive"); + if (test->min.set) { + fprintf (stderr, " min=%s", mc_dec128_to_string (test->min.value).str); + } + if (test->max.set) { + fprintf (stderr, " max=%s", mc_dec128_to_string (test->max.value).str); + } + if (test->precision.set) { + fprintf (stderr, " precision=%" PRIu32, test->precision.value); + } + fprintf (stderr, " sparsity=%zu\n", test->sparsity); + fprintf (stderr, "mincover expected ... begin\n"); + for (const char **p = test->expectMincoverStrings; *p; ++p) { + fprintf (stderr, " %s\n", *p); + } fprintf (stderr, "mincover expected ... end\n"); fprintf (stderr, "mincover got ... begin\n"); for (size_t i = 0; i < mc_mincover_len (got); i++) { @@ -350,35 +375,44 @@ _test_getMincover_impl (void *tests, } ASSERT_OK_STATUS (got != NULL, status); - args.expectMincover_init (tests, i); size_t numGot = mc_mincover_len (got); - mc_array_t *expectMincover = args.expectMincover (tests, i); - size_t numExpected = expectMincover->len; + const char *const *expectStrings = args.expectMincoverStrings (tests, i); + + const char *const *exp_iter = expectStrings; + size_t nthItem = 0; + for (; *exp_iter; ++nthItem, ++exp_iter) { + if (nthItem > numGot) { + // List length mismatch. Keep scanning, though. We'll use the + // numbers later + continue; + } + const char *gotItem = mc_mincover_get (got, nthItem); + const char *expectItem = *exp_iter; - if (numExpected != numGot) { - args.dump (tests, i, got); - TEST_ERROR ("test %zu: got %zu mincover, expected %zu mincover\n", + if (0 == strcmp (gotItem, expectItem)) { + // This one matches, Keep going. + continue; + } + args.dump (tests, nthItem, got); + TEST_ERROR ("test %zu: mincover mismatch at index %zu:\n" + " Got: %s\n" + " Expected: %s\n", i, - numGot, - numExpected); + nthItem, + gotItem, + expectItem); } - for (size_t gotI = 0; gotI < numGot; gotI++) { - const char *edgeGot = mc_mincover_get (got, gotI); - const char *edgeExpected = - _mc_array_index (expectMincover, const char *, gotI); - if (0 == strcmp (edgeGot, edgeExpected)) { - continue; - } + if (nthItem != numGot) { args.dump (tests, i, got); - TEST_ERROR ("test %zu: edge mismatch at index %zu. %s != %s\n", - i, - gotI, - edgeGot, - edgeExpected); + TEST_ERROR ( + "test %zu: Got the wrong number of mincover items. Expected %zu " + "items, but got %zu\n", + i, + nthItem, + numGot); } - expectMincover_cleanup (expectMincover); mc_mincover_destroy (got); mongocrypt_status_destroy (status); } @@ -395,7 +429,7 @@ _test_getMincoverInt32 (_mongocrypt_tester_t *tester) .min = OPT_I32_C (0), .max = OPT_I32_C (7), .sparsity = 1, - .expectMincoverString = "01\n"}, + .expectMincoverStrings = {"01"}}, {.lowerBound = 1, .includeLowerBound = true, .upperBound = 3, @@ -403,8 +437,7 @@ _test_getMincoverInt32 (_mongocrypt_tester_t *tester) .min = OPT_I32_C (0), .max = OPT_I32_C (7), .sparsity = 1, - .expectMincoverString = "001\n" - "010\n"}, + .expectMincoverStrings = {"001", "010"}}, {.lowerBound = 1, .includeLowerBound = true, .upperBound = 3, @@ -412,8 +445,7 @@ _test_getMincoverInt32 (_mongocrypt_tester_t *tester) .min = OPT_I32_C (0), .max = OPT_I32_C (7), .sparsity = 1, - .expectMincoverString = "001\n" - "01\n"}, + .expectMincoverStrings = {"001", "01"}}, {.lowerBound = 3, .includeLowerBound = true, .upperBound = 3, @@ -421,7 +453,7 @@ _test_getMincoverInt32 (_mongocrypt_tester_t *tester) .min = OPT_I32_C (0), .max = OPT_I32_C (7), .sparsity = 1, - .expectMincoverString = "011\n"}, + .expectMincoverStrings = {"011"}}, {.lowerBound = 4, .includeLowerBound = true, .upperBound = 3, @@ -447,9 +479,7 @@ _test_getMincoverInt32 (_mongocrypt_tester_t *tester) tests, sizeof (tests) / sizeof (tests[0]), (_test_getMincover_args){.getMincover = _test_getMincover32, - .expectMincover_init = - _test_expectMincover_init32, - .expectMincover = _test_expectMincover32, + .expectMincoverStrings = _test_expectMincover32, .expectError = _test_expectError32, .dump = _test_dump_32}); } @@ -465,7 +495,7 @@ _test_getMincoverInt64 (_mongocrypt_tester_t *tester) .min = OPT_I64_C (0), .max = OPT_I64_C (7), .sparsity = 1, - .expectMincoverString = "01\n"}, + .expectMincoverStrings = {"01"}}, {.lowerBound = 1, .includeLowerBound = true, .upperBound = 3, @@ -473,8 +503,7 @@ _test_getMincoverInt64 (_mongocrypt_tester_t *tester) .min = OPT_I64_C (0), .max = OPT_I64_C (7), .sparsity = 1, - .expectMincoverString = "001\n" - "010\n"}, + .expectMincoverStrings = {"001", "010"}}, {.lowerBound = 1, .includeLowerBound = true, .upperBound = 3, @@ -482,8 +511,7 @@ _test_getMincoverInt64 (_mongocrypt_tester_t *tester) .min = OPT_I64_C (0), .max = OPT_I64_C (7), .sparsity = 1, - .expectMincoverString = "001\n" - "01\n"}, + .expectMincoverStrings = {"001", "01"}}, {.lowerBound = 3, .includeLowerBound = true, .upperBound = 3, @@ -491,7 +519,7 @@ _test_getMincoverInt64 (_mongocrypt_tester_t *tester) .min = OPT_I64_C (0), .max = OPT_I64_C (7), .sparsity = 1, - .expectMincoverString = "011\n"}, + .expectMincoverStrings = {"011"}}, {.lowerBound = 4, .includeLowerBound = true, .upperBound = 3, @@ -517,9 +545,7 @@ _test_getMincoverInt64 (_mongocrypt_tester_t *tester) tests, sizeof (tests) / sizeof (tests[0]), (_test_getMincover_args){.getMincover = _test_getMincover64, - .expectMincover_init = - _test_expectMincover_init64, - .expectMincover = _test_expectMincover64, + .expectMincoverStrings = _test_expectMincover64, .expectError = _test_expectError64, .dump = _test_dump_64}); } @@ -536,17 +562,35 @@ _test_getMincoverDouble (_mongocrypt_tester_t *tester) tests, sizeof (tests) / sizeof (tests[0]), (_test_getMincover_args){.getMincover = _test_getMincoverDouble_helper, - .expectMincover_init = - _test_expectMincover_initDouble, - .expectMincover = _test_expectMincoverDouble, + .expectMincoverStrings = + _test_expectMincoverDouble, .expectError = _test_expectErrorDouble, .dump = _test_dump_Double}); } +static void +_test_getMincoverDecimal128 (_mongocrypt_tester_t *tester) +{ + Decimal128Test tests[] = { +#include "./data/range-min-cover/mincover_decimal128.cstruct" +#include "./data/range-min-cover/mincover_decimal128_precision.cstruct" + }; + + _test_getMincover_impl ( + tests, + sizeof (tests) / sizeof (tests[0]), + (_test_getMincover_args){ + .getMincover = _test_getMincoverDecimal128_helper, + .expectMincoverStrings = _test_expectMincoverDecimal128, + .expectError = _test_expectErrorDecimal128, + .dump = _test_dump_Decimal128}); +} + void _mongocrypt_tester_install_range_mincover (_mongocrypt_tester_t *tester) { INSTALL_TEST (_test_getMincoverInt32); INSTALL_TEST (_test_getMincoverInt64); INSTALL_TEST (_test_getMincoverDouble); + INSTALL_TEST (_test_getMincoverDecimal128); } diff --git a/test/test-mongocrypt-assert-match-bson.c b/test/test-mongocrypt-assert-match-bson.c index 7cc20bc81..6e2900db6 100644 --- a/test/test-mongocrypt-assert-match-bson.c +++ b/test/test-mongocrypt-assert-match-bson.c @@ -17,11 +17,7 @@ #include "test-mongocrypt-assert-match-bson.h" #include "test-mongocrypt-assert.h" -#ifndef _WIN32 -#define MONGOCRYPT_PRINTF_FORMAT(a, b) __attribute__ ((format (__printf__, a, b))) -#else -#define MONGOCRYPT_PRINTF_FORMAT(a, b) /* no-op */ -#endif +#include /* string comparison functions for Windows */ #ifdef _WIN32 @@ -175,7 +171,7 @@ single_quotes_to_double (const char *str) *-------------------------------------------------------------------------- */ -MONGOCRYPT_PRINTF_FORMAT (6, 7) +MLIB_ANNOTATE_PRINTF (6, 7) bool match_json (const bson_t *doc, bool is_command, @@ -264,7 +260,7 @@ match_bson (const bson_t *doc, const bson_t *pattern, bool is_command) } -MONGOCRYPT_PRINTF_FORMAT (2, 3) +MLIB_ANNOTATE_PRINTF (2, 3) void match_err (match_ctx_t *ctx, const char *fmt, ...) { @@ -991,9 +987,10 @@ match_bson_value (const bson_value_t *doc, } break; default: - match_err (ctx, "unexpected value type %d: %s", - doc->value_type, - _mongoc_bson_type_to_str (doc->value_type)); + match_err (ctx, + "unexpected value type %d: %s", + doc->value_type, + _mongoc_bson_type_to_str (doc->value_type)); } if (!ret) { diff --git a/test/test-mongocrypt-assert.h b/test/test-mongocrypt-assert.h index e8c41b6f4..b2dd63baf 100644 --- a/test/test-mongocrypt-assert.h +++ b/test/test-mongocrypt-assert.h @@ -168,6 +168,21 @@ #define ASSERT_CMPDOUBLE(a, eq, b) ASSERT_CMP_HELPER (a, eq, b, "f", double) #define ASSERT_CMPPTR(a, eq, b) ASSERT_CMP_HELPER (a, eq, b, "p", const void *) +#define ASSERT_CMPINT128_EQ(A, B) \ + if (1) { \ + mlib_int128 left = (A); \ + mlib_int128 right = (B); \ + const bool result = mlib_int128_eq (left, right); \ + if (!result) { \ + TEST_ERROR ("Comparison failed: %s == %s (%s != %s)", \ + #A, \ + #B, \ + mlib_int128_format (left).str, \ + mlib_int128_format (right).str); \ + } \ + } else \ + ((void) 0) + #define ASSERT_EQUAL_BSON(expected, actual) \ do { \ bson_t *_expected_bson = expected, *_actual_bson = actual; \ diff --git a/test/test-mongocrypt-ctx-encrypt.c b/test/test-mongocrypt-ctx-encrypt.c index 9cfba7a09..b6549931a 100644 --- a/test/test-mongocrypt-ctx-encrypt.c +++ b/test/test-mongocrypt-ctx-encrypt.c @@ -2617,6 +2617,32 @@ _test_encrypt_fle2_insert_range_payload_double_precision ( } #undef RNG_DATA +#include "./data/fle2-insert-range/decimal128/RNG_DATA.h" +static void +_test_encrypt_fle2_insert_range_payload_decimal128 ( + _mongocrypt_tester_t *tester) +{ + uint8_t rng_data[] = RNG_DATA; + _test_rng_data_source source = { + .buf = {.data = rng_data, .len = sizeof (rng_data) - 1u}}; + _test_encrypt_fle2_encryption_placeholder ( + tester, "fle2-insert-range/decimal128", &source); +} +#undef RNG_DATA + +#include "./data/fle2-insert-range/decimal128-precision/RNG_DATA.h" +static void +_test_encrypt_fle2_insert_range_payload_decimal128_precision ( + _mongocrypt_tester_t *tester) +{ + uint8_t rng_data[] = RNG_DATA; + _test_rng_data_source source = { + .buf = {.data = rng_data, .len = sizeof (rng_data) - 1u}}; + _test_encrypt_fle2_encryption_placeholder ( + tester, "fle2-insert-range/decimal128-precision", &source); +} +#undef RNG_DATA + // FLE2FindRangePayload only uses deterministic token generation. static void _test_encrypt_fle2_find_range_payload_int32 (_mongocrypt_tester_t *tester) @@ -2663,6 +2689,25 @@ _test_encrypt_fle2_find_range_payload_double_precision ( tester, "fle2-find-range/double-precision", &source); } +// FLE2FindRangePayload only uses deterministic token generation. +static void +_test_encrypt_fle2_find_range_payload_decimal128 (_mongocrypt_tester_t *tester) +{ + _test_rng_data_source source = {{0}}; + _test_encrypt_fle2_encryption_placeholder ( + tester, "fle2-find-range/decimal128", &source); +} + +// FLE2FindRangePayload only uses deterministic token generation. +static void +_test_encrypt_fle2_find_range_payload_decimal128_precision ( + _mongocrypt_tester_t *tester) +{ + _test_rng_data_source source = {{0}}; + _test_encrypt_fle2_encryption_placeholder ( + tester, "fle2-find-range/decimal128-precision", &source); +} + static mongocrypt_t * _crypt_with_rng (_test_rng_data_source *rng_source) { @@ -5031,9 +5076,13 @@ _mongocrypt_tester_install_ctx_encrypt (_mongocrypt_tester_t *tester) INSTALL_TEST (_test_encrypt_fle2_insert_range_payload_date); INSTALL_TEST (_test_encrypt_fle2_insert_range_payload_double); INSTALL_TEST (_test_encrypt_fle2_insert_range_payload_double_precision); + INSTALL_TEST (_test_encrypt_fle2_insert_range_payload_decimal128); + INSTALL_TEST (_test_encrypt_fle2_insert_range_payload_decimal128_precision); INSTALL_TEST (_test_encrypt_fle2_find_range_payload_int32); INSTALL_TEST (_test_encrypt_fle2_find_range_payload_int64); INSTALL_TEST (_test_encrypt_fle2_find_range_payload_date); INSTALL_TEST (_test_encrypt_fle2_find_range_payload_double); INSTALL_TEST (_test_encrypt_fle2_find_range_payload_double_precision); + INSTALL_TEST (_test_encrypt_fle2_find_range_payload_decimal128); + INSTALL_TEST (_test_encrypt_fle2_find_range_payload_decimal128_precision); } diff --git a/test/util/make_includes.py b/test/util/make_includes.py new file mode 100644 index 000000000..d6fd533be --- /dev/null +++ b/test/util/make_includes.py @@ -0,0 +1,845 @@ +""" +Script to convert the MongoDB server test vector #include files into their +libmongocrypt C-equivalent counterpart. + +Pass a single argument naming the "kind" of objects to parse. +Code is read from stdin and written to stdout:: + + > python make_includes.py edges < from_server/edges.cstruct > for_libmongocrypt/edges.cstruct + > python make_includes.py mincovers < from_server/mincovers.cstruct > for_libmongocrypt/mincovers.cstruct +""" + +from __future__ import annotations + +import argparse +import itertools +import json +import re +import sys +from itertools import chain +from typing import (Callable, Generic, Iterable, NamedTuple, Sequence, TypeVar, + Union, cast) + +T = TypeVar('T') + + +class Number(NamedTuple): + """Stores a numeric literal (integer or float).""" + spell: str + + def __str__(self) -> str: + return self.spell + + +class String(NamedTuple): + """Stores a quoted string literal.""" + spell: str + + def __str__(self) -> str: + return self.spell + + +class Ident(NamedTuple): + """Stores a bare C-style identifier""" + spell: str + + def __str__(self) -> str: + return self.spell + + +class TmplIdent(NamedTuple): + """ + Stores a template-specialization identifier. + """ + name: str + "The C identifier of the template's name" + targs: Sequence[Expression] + "The argument expressions given for the template specialization" + + def __str__(self) -> str: + return f'{self.name}<{", ".join(map(str, self.targs))}>' + + +class PrefixExpr(NamedTuple): + """Stores a unary prefix expression""" + operator: str + "The spelling of the prefix operator" + operand: Expression + "The expression on the right-hand side of the operator" + + def __str__(self) -> str: + return f'{self.operator}{self.operand}' + + +class InfixExpr(NamedTuple): + """Stores a binary infix expression""" + lhs: Expression + "The left-hand operand of the expression" + oper: str + "The spelling of the infix operator" + rhs: Expression + "The right-hand operand of the expression" + + def __str__(self) -> str: + return f'{self.lhs} {self.oper} {self.rhs}' + + +class CallExpr(NamedTuple): + """Stores a function-call expression""" + fn: Expression + "The callable expression being used as the function" + args: Sequence[Expression] + "The arguments being passed to the function" + + def __str__(self) -> str: + return f'{self.fn}<{", ".join(map(str, self.args))}>' + + +class ScopeExpr(NamedTuple): + """A scope-resolution '::' infix expression""" + left: Expression + "The left-hand operand of the scope-resolution" + name: Ident | TmplIdent + "The inner name being resolved" + + def __str__(self) -> str: + return f'{self.left}::{self.name}' + + +class InitList(NamedTuple): + """Stores a brace-enclosed initializer-list""" + elems: Sequence[Expression] + "The elements of the init-list" + + def __str__(self) -> str: + return f'{{{", ".join(map(str, self.elems))}}}' + + +Expression = Union[PrefixExpr, CallExpr, String, Number, InitList, ScopeExpr, + InfixExpr, TmplIdent, Ident] +"An arbitrary expression (from a small subset of C++)" + +BOOST_NONE = ScopeExpr(Ident('boost'), Ident('none')) +"Shorthand for the encoded 'boost::none' expression" + + +class EdgeInfo(NamedTuple): + """Represents a single edge test vector from a C++ #include file""" + func: Expression + "The function that is used to generate the edge" + value: Expression + "The expression given as the first value" + min: Expression + "The min value for the edge" + max: Expression + "The max value for the edge" + sparsity: Expression + "The sparsity of the edge" + precision: Expression + "The precision of the edge" + edges: Expression + "The edges given for the test" + + +class MinCoverInfo(NamedTuple): + """Represents a single mincover test vector""" + lb: Expression + "Lower bound for the operation, if provided" + ub: Expression + "Upper bound for the operation, if provided" + min: Expression + "Minimum value" + max: Expression + "Maximum value" + sparsity: Expression + "Sparsity of the mincover" + precision: Expression + "Optional: Precision of the range" + expect_string: Expression + "The expected result string" + + +class Token(NamedTuple): + """A token consumed from the input""" + spell: str + "The spelling of the token" + line: int + "The line on which the token appears" + + @property + def is_id(self) -> bool: + """Is this an identifier?""" + return IDENT_RE.match(self.spell) is not None + + @property + def is_num(self) -> bool: + """Is this a number?""" + return NUM_RE.match(self.spell) is not None + + @property + def is_str(self) -> bool: + """Is this a string literal?""" + return STRING_RE.match(self.spell) is not None + + def __repr__(self) -> str: + return f'' + + +IDENT_RE = re.compile(r'^[a-zA-Z_]\w*') +"Matches a C identifier" +NUM_RE = re.compile( + r'''^ + # The unfortunate many ways to write a number + # First: Floats: + ( + ( \d+\.\d+ # Both whole and fractional part + | \.\d+ # ".NNNN" (No whole part) + | \d+\. # "NNNN." (no fractional part) + ) + # Optional: "f" suffix + f? + # Integers: + )|( + ( + 0x # Hex prefix + [0-9a-fA-F']+ # Hex digits (with digit separator) + + | 0 # Octal prefix + [0-7']* # May have no digits. "0" is an octal literal oof. + + | 0b # Binary prefix + [01'] # Bits + + | [1-9] # Decimal integer + [0-9']* + ) + # There could be a type modifying suffix: + [uU]? # Unsigned + [lL]{0,2} # Long, or VERY long + ) +''', re.VERBOSE) +"Matches an integer or float numeric literal" +STRING_RE = re.compile( + r''' + # Regular strings: + "(\\.|[^"])*" + | # Raw strings: + R + " + (?P.*?) # The delimiter + \( + (?P(.|\s)*?) + \) + (?P=delim) # Stop when we find the delimiter again + " +''', re.VERBOSE) +"Matches a string literal" +LINE_COMMENT_RE = re.compile(r'^//.*?\n\s*') +WHITESPACE_RE = re.compile(r'[ \n\t\r\f]+') +"Matches one or more whitespace tokens" + + +def cquote(s: str) -> str: + """Enquote a string to be used as a C string literal""" + # Coincidentally, JSON strings are valid C strings + return json.dumps(s) + + +def join_with(items: Iterable[T], by: Iterable[T]) -> Iterable[T]: + """ + Yield every item X in 'items'. Between each X, yield each item in `by`. + """ + STOP = object() + # Iterate each item, and yield the sentinel STOP when we finish. + # This is far easier than dancing around StopIteration. + ch = chain(items, [STOP]) + it = iter(ch) + item = next(it) + while item is not STOP: + yield cast(T, item) + item = next(it) + if item is not STOP: + # Clone the iterable so we can re-iterate it again later: + by, tee = itertools.tee(by, 2) + yield from tee + + +class Scanner: + """ + Consumes a given string, keeping track of line and column position information. + """ + + def __init__(self, s: str) -> None: + self._str = s + self._off = 0 + self._line = 1 + self._col = 1 + + @property + def string(self) -> str: + """Return the current string content""" + return self._str[self._off:] + + @property + def line(self): + """The current line number""" + return self._line + + @property + def col(self): + """The current column number""" + return self._col + + def consume(self, n: int) -> None: + """ + Discard n characters from the input + """ + skipped = self.string[:n] + self._line += skipped.count('\n') + nlpos = skipped.rfind('\n') + if nlpos >= 0: + self._col = len(skipped) - nlpos + self._off += n + + def skipws(self): + """ + Consume all whitespace at the beginning of the current input + """ + ws = WHITESPACE_RE.match(self.string) + if not ws: + return + self.consume(len(ws[0])) + + +def tokenize(sc: Scanner) -> Iterable[Token]: + """Lazily extracts and yields tokens from the given code string""" + # Discard leading space, of course: + sc.skipws() + while sc.string: + # If we have a comment, just skip it: + comment = LINE_COMMENT_RE.match(sc.string) + if comment: + sc.consume(len(comment[0])) + sc.skipws() + continue + + # Try to match basic primary tokens. A "real" C++ tokenizer needs to be + # context-sensitive, but we only implement "just enough" to be useful. + mat = ( + STRING_RE.match(sc.string) # + or IDENT_RE.match(sc.string) # + or NUM_RE.match(sc.string)) + if mat: + # A basic token: Strings, identifiers, and number literals. + tok = mat[0] + yield Token(tok, sc.line) + sc.consume(len(tok)) + elif sc.string.startswith('::'): + # Scope resolution operator + yield Token(sc.string[:2], sc.line) + sc.consume(2) + elif sc.string[0] in ',&}{[]().-<>+': + # Basic one-character punctuators. We don't handle any digraphs. + yield Token(sc.string[0], sc.line) + sc.consume(1) + else: + # Unknown. Generate an error: + snippet = sc.string[:min(len(sc.string), 30)] + raise RuntimeError(f'Unknown token at {cquote(snippet)} ' + f'(Line {sc.line}, column {sc.col})"') + sc.skipws() + + +class LazyList(Generic[T]): + """ + Create a forward-only list that lazily advances an iterable as items are + requested, and drops items as they are discarded. + """ + + def __init__(self, it: Iterable[T]) -> None: + self._iter = iter(it) + self._acc: list[T | None] = [] + + def at(self, n: int) -> T | None: + """Return the Nth element from the sequence, or 'None' if at the end.""" + while n >= len(self._acc): + # We need to add to the list. Append 'None' if there's nothing left + self._acc.append(next(self._iter, None)) + return self._acc[n] + + def adv(self, n: int = 1) -> None: + """Discard N elements from the beginning of the sequence.""" + self._acc = self._acc[n:] + + +Tokenizer = LazyList[Token] +"A token-generating lazy list" + + +def parse_ilist(toks: Tokenizer) -> InitList: + """Parse a braced init-list, e.g. {1, 2, 3}""" + lbr = toks.at(0) + assert lbr and lbr.spell == '{', f'Expected left-brace "{{" (Got {lbr=})' + toks.adv() + acc: list[Expression] = [] + while 1: + peek = toks.at(0) + assert peek, 'Unexpected EOF parsing init-list' + # If we see a closing brace, that's the end + if peek.spell == '}': + toks.adv() + break + # Expect an element: + expr = parse_expr(toks) + acc.append(expr) + peek = toks.at(0) + assert peek, 'Unexpected EOF parsing init-list' + # We expect either a comma or a closing brace: + assert peek.spell in ( + '}', ',' + ), f'Expected comma or closing brace following init-list element (Got "{peek=}")' + if peek.spell == ',': + # Just skip the comma. This may or may not be followed by another element. + toks.adv() + return InitList(acc) + + +def parse_call_args(toks: Tokenizer, + begin: str = '(', + end: str = ')') -> Sequence[Expression]: + """ + Parse the argument list of a function/template call. The tokenizer must be + positioned at the opening token. This function expects and will consume the + closing token from the input. + """ + lpar = toks.at(0) + assert lpar and lpar.spell == begin, f'Expected opening "{begin}" (Got {lpar=})' + toks.adv() + acc: list[Expression] = [] + + peek = toks.at(0) + while peek and peek.spell != end: + # Parse an argument: + x = parse_expr(toks) + acc.append(x) + # We expect either a comma or a closing token next: + peek = toks.at(0) + assert peek, 'Unexpected EOF following argument in call expression' + assert peek.spell in ( + ',', end + ), f'Expected comma or "{end}" following argument (Got "{peek}")' + # Skip over the comma, if present + if peek.spell == ',': + # Consume the comma: + toks.adv() + assert peek and peek.spell == end + # Discard the closing token: + toks.adv() + return acc + + +def parse_nameid(toks: Tokenizer) -> Ident | TmplIdent: + """ + Parse a name-id. This may be a bare identifier, or an identifier followed by + template arguments. We don't handle less-than expressions correctly, but this + dosen't matter for our current inputs. A more sofisticated system may be + required later on. + """ + idn = toks.at(0) + assert idn and idn.is_id, f'Expected identifier beginning a nameid (Got {idn=}' + toks.adv() + angle = toks.at(0) + if not angle or angle.spell != '<': + # A regular identifier + return Ident(idn.spell) + # An identifier with template arguments: + # (Or, an itentifier followed by a less-than symbol. We don't handle that + # case, and don't currently need to.) + targs = parse_call_args(toks, '<', '>') + return TmplIdent(idn.spell, targs) + + +def parse_expr(toks: Tokenizer) -> Expression: + """Parses an arbitrary C++-ish expression.""" + return parse_infix(toks) + + +def parse_infix(toks: Tokenizer) -> Expression: + """Parse a binary infix-expression. Only handles leff-associativity.""" + x = parse_prefix_expr(toks) + peek = toks.at(0) + while peek: + s = peek.spell + if s not in '+-': + break + # Binary "+" or "-" (We don't care about other operators (yet)) + toks.adv() + rhs = parse_prefix_expr(toks) + x = InfixExpr(x, s, rhs) + peek = toks.at(0) + return x + + +def parse_prefix_expr(toks: Tokenizer) -> Expression: + """Parses a unary prefix expression (currently, only '&' and '-' are handled).""" + peek = toks.at(0) + if peek and peek.spell in '-&': + toks.adv() + x = parse_prefix_expr(toks) + return PrefixExpr(peek.spell, x) + return parse_suffix_expr(toks) + + +def parse_suffix_expr(toks: Tokenizer) -> Expression: + """Parses a suffix-expression (For now, that only includes call expressions and scope resolution).""" + x = parse_primary_expr(toks) + peek = toks.at(0) + # Look ahead for scope resolution or function call (could also handle + # dot '.' and subscript, but we don't care (yet)) + while peek: + if peek.spell == '::': + # Scope resolution: + toks.adv() + name = parse_nameid(toks) + x = ScopeExpr(x, name) + elif peek.spell == '(': + # Function call: + args = parse_call_args(toks) + x = CallExpr(x, args) + else: + break + peek = toks.at(0) + return x + + +def parse_primary_expr(toks: Tokenizer) -> Expression: + """Parses a primary expression (IDs, literals, parentheticals, and init-lists).""" + x: Expression + peek = toks.at(0) + assert peek, 'Unexpected EOF when expected an expression' + if peek.spell == '{': + x = parse_ilist(toks) + elif peek.is_str: + x = String(peek.spell) + toks.adv() + elif peek.is_id: + x = parse_nameid(toks) + elif peek.is_num: + x = Number(peek.spell) + toks.adv() + else: + raise RuntimeError(f'Unknown expression beginning with token "{peek}"') + return x + + +def parse_edges(toks: Tokenizer) -> Iterable[EdgeInfo]: + """Lazily parses the edges from the given sequence of C++ tokens.""" + while toks.at(0): + ilist = parse_expr(toks) + assert isinstance( + ilist, InitList + ), f'Expected init-list for an edge element (Got {ilist!r})' + fn, val, lb, ub, sparse, edges = ilist.elems + yield EdgeInfo( + fn, + val, + lb, + ub, + sparse, + # Edges do not (yet) provide precision: + BOOST_NONE, + edges, + ) + peek = toks.at(0) + assert peek and peek.spell == ',', f'Expect a comma following edge element (Got {peek=})' + toks.adv() + + +def parse_mincovers(toks: Tokenizer) -> Iterable[MinCoverInfo]: + """Lazily parse MinCovert test vectors from the given C++ tokens.""" + while toks.at(0): + ilist = parse_expr(toks) + assert isinstance( + ilist, InitList + ), f'Expected init-list for a mincover element (Got {ilist!r})' + # Grab the first five params: + lb, ub, mn, mx, sparsity = ilist.elems[:5] + # The precision element is optional, and may not be present: + has_precision = len(ilist.elems) == 7 + prec = ilist.elems[5] if has_precision else BOOST_NONE + # The final element is teh expectation: + expect = ilist.elems[-1] + yield MinCoverInfo(lb, ub, mn, mx, sparsity, prec, expect) + peek = toks.at(0) + assert peek and peek.spell == ',', f'Expected comma following edge element (Got {peek=})' + toks.adv() + + +def _render_limit(typ: Expression, limit: Ident) -> Iterable[str]: + """ + Render a value from std::numeric_limits<>. We only use a few of them so far. + """ + if isinstance(typ, ScopeExpr) and str(typ.left) == 'std': + typ = typ.name + assert isinstance(typ, + Ident), f'Unimplemented type for numeric limits {typ=}' + mapping: dict[tuple[str, str], Expression] = { + ('int32_t', 'min'): Ident('INT32_MIN'), + ('int64_t', 'min'): Ident('INT64_MIN'), + ('double', 'min'): Ident('DBL_MIN'), + } + e = mapping[(typ.spell, limit.spell)] + return _render_expr(e) + + +def _render_call(c: CallExpr) -> Iterable[str]: + """ + Render a function call expression. This may render as some other arbitrary + expression since we need to handle C++-isms. + """ + # Intercept calls to numeric_limits: + if (isinstance(c.fn, ScopeExpr) # + and c.args == [] # + and isinstance(c.fn.left, ScopeExpr) # + and str(c.fn.left.left) == 'std' # + and isinstance(c.fn.left.name, TmplIdent) # + and c.fn.left.name.name == 'numeric_limits'): + # We're looking for numeric limits + assert isinstance(c.fn.name, Ident), f'Unimplemented limit: {c=}' + return _render_limit(c.fn.left.name.targs[0], c.fn.name) + + if str(c.fn) == 'std::string': + # We're constructing a std::string. All our inputs just use inline literals, so just render + # those. + assert len(c.args) == 1, c + assert isinstance(c.args[0], String), c + return _render_string(c.args[0]) + + # Intercept calls to "Decimal128" + if c.fn == Ident('Decimal128'): + assert len(c.args) == 1, f'Too many args for Decimal128? {c=}' + arg = c.args[0] + if isinstance(arg, Number) and '.' not in arg.spell: + # We can convert from an integer driectly + return _render_call(CallExpr(Ident('MC_DEC128'), [arg])) + if isinstance(arg, String): + # They're passing a string to Decimal128(), so we do the same + return _render_call(CallExpr(Ident('mc_dec128_from_string'), + [arg])) + # Other argument: + assert isinstance( + arg, (Number, + PrefixExpr)), f'Unimplemented argument to Decimal128: {arg=}' + # Wrap the argument in a string, since a double literal may lose precision and generate an incorrect value: + call = CallExpr(Ident('mc_dec128_from_string'), + [String(cquote(str(arg)))]) + return _render_call(call) + # Otherwise: Render anything else as just a function call: + fn = _render_expr(c.fn) + each_arg = map(_render_expr, c.args) + comma_args = join_with(each_arg, ', ') + args = chain.from_iterable(comma_args) + return chain(fn, '(', args, ')') + + +def _render_scope(e: ScopeExpr) -> Iterable[str]: + """ + Render a scope resolution expression. This only cares about constants of + Decimal128 yet. + """ + if e.left == Ident('Decimal128') and isinstance(e.name, Ident): + # Looking up a constant on Decimal128, presumably + attr = e.name + const = { + 'kLargestPositive': 'MC_DEC128_LARGEST_POSITIVE', + 'kLargestNegative': 'MC_DEC128_LARGEST_NEGATIVE', + }[attr.spell] + return [const] + assert False, f'Unimplemented scope-resolution expression: {e=}' + + +def _render_infix(e: InfixExpr) -> Iterable[str]: + if isinstance(e.rhs, String) and e.oper == '+': + # We're building a string with operator+. We don't have a special + # "string concat" to use, so just do preprocessor string splicing + # (for now). This also assumes that the operands are also string literals or other string + # concatenations, but that's all we need for now. + return chain(_render_expr(e.lhs), _render_expr(e.rhs)) + # We don't implement any other infix expressions yet. + assert False, f'Unimplemented infix expression: {e=}' + + +def _get_stdstring_concat_content(s: InfixExpr) -> str: + left = get_string_content(s.lhs) + right = get_string_content(s.rhs) + return left + right + + +def get_string_content(s: Expression) -> str: + if isinstance(s, InfixExpr): + return _get_stdstring_concat_content(s) + if isinstance(s, CallExpr) and str(s.fn) == 'std::string': + # We're constructing a std::string. All our inputs just use inline literals, so just render + # those. + assert len(s.args) == 1, s + return get_string_content(s.args[0]) + assert isinstance( + s, String + ), f'Attempting to pull the content of a non-string expression: {s!r}' + if not s.spell.startswith('R'): + # Just a regular string. + return json.loads(s.spell) + # C doesn't support the R"()" 'raw string' (yet). We'll un-prettify it: + mat = STRING_RE.match(s.spell) + assert mat, s + return mat.group('raw_content') + + +def _render_string(s: String) -> Iterable[str]: + """ + Render a string literal. + """ + c = get_string_content(s) + lines = c.splitlines() + if '\n' in c: + lines = (f'{l}\n' for l in lines) + quoted = map(cquote, lines) + return join_with(quoted, '\n ') + + +def _render_initlist(i: InitList) -> Iterable[str]: + exprs = map(_render_expr, i.elems) + with_comma = chain.from_iterable(chain('\n ', x, ',') for x in exprs) + return chain('{', with_comma, '\n }') + + +def _render_expr(e: Expression) -> Iterable[str]: + """ + Generate a rendering of an arbitrary expression + """ + if isinstance(e, (Number, Ident)): + return [e.spell] + elif isinstance(e, String): + return _render_string(e) + elif isinstance(e, CallExpr): + return _render_call(e) + elif isinstance(e, PrefixExpr): + return chain(e.operator, _render_expr(e.operand)) + elif isinstance(e, ScopeExpr): + return _render_scope(e) + elif isinstance(e, InfixExpr): + return _render_infix(e) + elif isinstance(e, InitList): + return _render_initlist(e) + else: + assert False, f'Do not know how to render expression: {e=}' + + +def _render_opt_wrap(e: Expression) -> Iterable[str]: + """ + Render a value that is wrapped as an optional. If boost::none, emits a + braced-init "{.set = false}", otherwise "{.set=true, .value = render(e) }" + """ + if e == BOOST_NONE: + return '{ .set = false }' + return chain('{ .set = true, .value = ', _render_expr(e), ' }') + + +def designit(attr: str, x: Iterable[str]) -> Iterable[str]: + """ + Render a 2-space indented designated initializer, with a trailing comma + and newline + """ + return chain(f' .{attr} = ', x, ',\n') + + +def render_edge(e: EdgeInfo) -> Iterable[str]: + # Permute the edge list for easier matching + elist = e.edges + assert isinstance(elist, InitList) + fin = elist.elems[-1] + leaf = elist.elems[-2] + prefix = elist.elems[:-2] + reordered = chain((fin, leaf), prefix) + wrapped = (chain('\n ', _render_expr(e), ',') for e in reordered) + braced_edges = chain('{', chain.from_iterable(wrapped), '\n }') + + return chain( + '{\n', + designit('value', _render_expr(e.value)), + designit('min', _render_opt_wrap(e.min)), + designit('max', _render_opt_wrap(e.max)), + # The upstream vectors include a 'precision' field, but we don't use it (yet). + # designit('precision', _render_opt_wrap(e.precision)), + designit('sparsity', _render_expr(e.sparsity)), + designit('expectEdges', braced_edges), + '},\n', + ) + + +def split_mincover_string(s: Expression) -> Iterable[str]: + content = get_string_content(s) + lines = content.splitlines() + quoted = map(cquote, lines) + as_exprs = map(String, quoted) + return _render_expr(InitList(list(as_exprs))) + + +def render_mincover(mc: MinCoverInfo) -> Iterable[str]: + return chain( + '{\n', + designit('lowerBound', _render_expr(mc.lb)), + designit('includeLowerBound', 'true'), + designit('upperBound', _render_expr(mc.ub)), + designit('includeUpperBound', 'true'), + designit('sparsity', _render_expr(mc.sparsity)), + designit('min', _render_opt_wrap(mc.min)), + designit('max', _render_opt_wrap(mc.max)), + () if mc.precision is BOOST_NONE # + else designit('precision', _render_opt_wrap(mc.precision)), + designit('expectMincoverStrings', + split_mincover_string(mc.expect_string)), + '},\n', + ) + + +def generate(code: str, parser: Callable[[Tokenizer], Iterable[T]], + render: Callable[[T], Iterable[str]]): + """ + Generate code. + + :param code: The input code to parse. + :param parser: A parsing function that accepts a tokenizer and emits objects of type T. + :param render: A renderer that accepts instances of T and returns an iterable of strings. + + For every object V yielded by parse(tokens), every string + yielded from render(V) will be written to stdout. + """ + scan = Scanner(code) + toks = LazyList(tokenize(scan)) + print('// This code is GENERATED! Do not edit!') + print('// clang-format off') + items = parser(toks) + each_rendered = map(render, items) + strings = chain.from_iterable(each_rendered) + for s in strings: + sys.stdout.write(s) + + +def main(argv: Sequence[str]): + parser = argparse.ArgumentParser() + parser.add_argument('kind', + help='What kind of construct are we parsing', + choices=['edges', 'mincovers']) + args = parser.parse_args(argv) + code = sys.stdin.read() + if args.kind == 'edges': + generate(code, parse_edges, render_edge) + elif args.kind == 'mincovers': + generate(code, parse_mincovers, render_mincover) + else: + assert False + + +if __name__ == '__main__': + main(sys.argv[1:])